home *** CD-ROM | disk | FTP | other *** search
/ Aminet 19 / Aminet 19 (1997)(GTI - Schatztruhe)[!][Jun 1997].iso / Aminet / dev / gui / MPGui5xs.lha / sg / MPGui.c < prev    next >
C/C++ Source or Header  |  1997-03-04  |  135KB  |  4,591 lines
  1. // MPGui - requester library
  2. // Copyright (C) © 1995 Mark John Paddock
  3.  
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // any later version.
  8.  
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13.  
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. // mark@topic.demon.co.uk
  19. // mpaddock@cix.compulink.co.uk
  20.  
  21. /****** MPGui.library/--background-- ****************************************
  22. *
  23. * MPGui provides an easy way to display simple single colum requesters with
  24. * File/String/Number/Slider/Cycle/Check/ScreenMode/List gadgets.
  25. *
  26. * It uses a text input file to specify the format of the Gui.
  27. *
  28. * Menus can be provided.
  29. *
  30. * Bottom gadgets can be "Ok/Cancel" for normal gadgets or "Save/Use/Cancel"
  31. * for preferences requesters.
  32. * From Version 5.2 the short cuts for these buttons will automatically be
  33. * disabled if required. The library is also localised.
  34. *
  35. * From Version 5.4 opens locale.library(38) to work on OS3.0.
  36. *
  37. * Normal Help and continuous Help is supported.
  38. *
  39. * Keyboard shortcuts are supported.
  40. *
  41. * The format of the file is:
  42. *
  43. * * comment
  44. *                  Comment line
  45. *
  46. * Any #n# (n>=0) will be replaced by parameters if supplied
  47. * ## is changed to # if parameters are supplied
  48. * 
  49. * Some standard C conversions are done with \ values
  50. *  \\ -> \
  51. *  \" -> "
  52. *  \t -> tab
  53. *  \n -> newline
  54. *
  55. * "command "HelpMessage
  56. *        etc.      Command (etc. is ignored)
  57. *  "Comment"       Comment for heading of requester
  58. *  "HelpNode"      Global Help Node for requester
  59. *  GADGET "Title":"prefix"!HelpNode!HelpMessage!
  60. *                         A Gadget
  61. *                         GAGDET is type of gadget (see below).
  62. *                         "Title" is gadget title
  63. *                         "prefix" appears before the value in the result
  64. *                                  if prefix includes %s then result
  65. *                                  replaces %s instead
  66. *                         !HelpNode! is optional help string to
  67. *                                    use in call back
  68. *                         !HelpMessage is displayed in text gadget at top
  69. *
  70. *  LFILE "Title":"prefix":"def"!Help!
  71. *                  Input file string and request gadget
  72. *                  Key activates
  73. *                  Right shift and key shows requester
  74. *  SFILE "Title":"prefix":"def"!Help!
  75. *                  Output file string and gadget
  76. *                  Key activates
  77. *                  Right shift and key shows requester
  78. *  FILE "T":"P":"def"!Help!
  79. *                  File string and request (input file)
  80. *                  Key activates
  81. *                  Right shift and key shows requester
  82. *  OFILE "T":"P":"def":Y/N!Help!
  83. *                  Optional file (has checkbox)
  84. *                  Key toggles and activates if becomes selectable
  85. *                  Left shift and key activates if selectable
  86. *                  Right shift and key shows requester if selectable
  87. *  ONUMBER "T":"P":"def":Y/N!Help!
  88. *                  Optional number (has checkbox)
  89. *                  Key toggles and activates if becomes selectable
  90. *                  Left shift and key activates if selectable
  91. *  NUMBER "T":"P":"def"!Help!
  92. *                  Number
  93. *                  Key activates
  94. *  CYCLE "Title"!Help!
  95. *                  Cycle gadget, each entry can be followed by other gadgets
  96. *                  Key cycles
  97. *                  Shift and key cycles back
  98. *        "value1":"Prefix1"
  99. *        "value2":"Prefix2"
  100. *     gadgets      
  101. *                  Only active when item is 2
  102. *        "value3":"Prefix3"
  103. *  ENDCYCLE:"number or valuen" 
  104. *                  Finished by default value (numeric or string)
  105. *  STRING "Title":"prefix":"def"!Help!
  106. *                  String - use for floating point as well
  107. *                  Key activates
  108. *  OSTRING "Title":"prefix":"def":Y/N!Hlp!
  109. *                  String with checkbox
  110. *                  Key toggles and activates if becomes selectable
  111. *                  Left shift and key activates if selectable
  112. *  CHECK "T":"P":"NPrefix":Y/N!Help
  113. *                  Check box gadget
  114. *                  NPrefix (optional) used if Check not selected
  115. *                  Key toggles
  116. *  SLIDER "T":"P":"min":"max":"def"!Hlp!
  117. *                  Slider gadget
  118. *                  Key increases
  119. *                  Shift and key decreases
  120. *  MODEn "T":"P":"def"!Help!
  121. *                  Screen Mode requester
  122. *                  Key shows requester
  123. *                  n == 1 -> Workbench modes
  124. *                       2 -> Workbench modes + NONE
  125. *                       3 -> All modes
  126. *                       4 -> All modes + NONE (3 and 4 do not work too well)
  127. *  OMODEn "T":"P":"def":Y/N!Help!
  128. *                  Optional Screen Mode requester
  129. *                  Key toggles
  130. *                  Right shift and key shows requester if selectable
  131. *  FONTn "T":"P":"def"!Help!
  132. *                  Font requester
  133. *                  Key shows requester
  134. *                  n == 1 -> All Fonts
  135. *                       2 -> Fixed width only
  136. *  OFONTn "T":"P":"def":Y/N!Help!
  137. *                  Optional Font requester
  138. *                  Key toggles
  139. *                  Right shift and key shows requester if selectable
  140. *  LIST "Title":!Help!
  141. *                  List view
  142. *                  Key cycles
  143. *                  Shift and key cycles back
  144. *       "value1":"prefix1"
  145. *       "value2":"prefix2"
  146. *  ENDLIST:"number or valuen":"lines"
  147. *                  finished by default value and lines (optional) default 4
  148. *  MLIST "Title":!Help!
  149. *                  List view
  150. *                  Key cycles
  151. *                  Left shift and key cycles back
  152. *                  Right shift and key toggles selected
  153. *       "value1":"prefix1":"NPrefix1" (Negative Prefix optional)
  154. *       "value2":"prefix2"
  155. *  ENDMLIST:"values":"lines"
  156. *                  finished by default selected values (space seperated)
  157. *                  and lines (optional) default 4
  158. *  BUTTON "Title"  List of button gadgets - horizontal
  159. *                  If Title zero length then full width is used
  160. *       "Button text1":"n"!Help!HelpMessage!  n is number of button
  161. *       "Button text2":"m"!Help!HelpMessage!
  162. *  ENDBUTTON
  163. *  TEXT "Title":"def"Y/N!Help!HelpMessage!    (added in 5.1)
  164. *                  Text - If title 0 length then full width
  165. *                  Y to Center Text
  166. *  MTEXT "def"Y/N!Help!HelpMessage!    (added in 5.1)
  167. *                  Text without border
  168. *                  Y to Center Text
  169. *
  170. *****************************************************************************
  171. *
  172. */
  173.  
  174. #include <dos.h>
  175.  
  176. #define USE_BUILTIN_MATH
  177. #include <string.h>
  178. #include <stdlib.h>
  179. #include <math.h>
  180.  
  181. #include <stddef.h>
  182. #include <stdarg.h>
  183. #include <ctype.h>
  184.  
  185. #define INTUI_V36_NAMES_ONLY
  186. #define INTUITION_IOBSOLETE_H
  187. #define ASL_V38_NAMES_ONLY
  188. #include <graphics/gfxbase.h>
  189. #include <proto/exec.h>
  190. #include <proto/gadtools.h>
  191. #include <proto/intuition.h>
  192. #include <proto/graphics.h>
  193. #include <proto/asl.h>
  194. #include <proto/dos.h>
  195. #include <proto/utility.h>
  196. #include <proto/locale.h>
  197.  
  198. #include <intuition/gadgetclass.h>
  199. #include <dos/dostags.h>
  200. #include <exec/memory.h>
  201.  
  202. extern long __oslibversion=39;
  203.  
  204. extern struct Catalog *Catalog=NULL;
  205.  
  206. #define CATCOMP_BLOCK
  207. #define CATCOMP_NUMBERS
  208. #include "messages.h"
  209.  
  210. #include "MPGui.h"
  211. #include "libraries/MPGui.h"
  212.  
  213. const char Version[]="$VER: MPGui.library 5.5 (4.3.97)";
  214.  
  215. struct MPGuiHandle * __asm __saveds AllocMPGuiHandleA(register __a0 struct TagItem * TagList);
  216. void __asm __saveds FreeMPGuiHandle(register __a0 struct MPGuiHandle * );
  217. char * __asm __saveds MPGuiError(register __a0 struct MPGuiHandle * );
  218. char * __asm __saveds SyncMPGuiRequest(register __a0 char * , register __a1 struct MPGuiHandle * );
  219. __saveds __asm ULONG MPGuiResponse(register __a0 struct MPGuiHandle *gh);
  220. __saveds __asm BOOL SetMPGuiGadgetValue(register __a0 struct MPGuiHandle *gh,
  221.                             register __a1 char *Title, register __a2 char *Value);
  222. __saveds __asm char *MPGuiCurrentAttrs(register __a0 struct MPGuiHandle *gh);
  223. void __saveds __asm RefreshMPGui(register __a0 struct MPGuiHandle *gh);
  224. struct Window * __saveds __asm MPGuiWindow(register __a0 struct MPGuiHandle *gh);
  225.  
  226. /* Internal prototypes */
  227. int sprintf(unsigned char * ,const unsigned char * , ...);
  228. unsigned char * mystrdup(struct MPGuiHandle * , unsigned char * );
  229. void Command(struct MPGuiHandle * );
  230. void pError(struct MPGuiHandle * , unsigned char const * , unsigned char * );
  231. unsigned char * myfgets(struct MPGuiHandle * );
  232. void ProcessGadget(struct MPGuiHandle * );
  233. void ProcessButton(struct MPGuiHandle * );
  234. void ProcessCycle(struct MPGuiHandle * );
  235. void ProcessList(struct MPGuiHandle * );
  236. void ProcessMList(struct MPGuiHandle * );
  237. void GetTitle(BOOL SetLeft,struct MPGuiHandle * );
  238. void GetParameter(struct MPGuiHandle * );
  239. void GetNParameter(struct MPGuiHandle * );
  240. void GetStringDefault(struct MPGuiHandle * );
  241. void GetNumberDefault(struct MPGuiHandle * );
  242. void GetCheckDefault(struct MPGuiHandle * );
  243. void GetDefCycle(struct MPGuiHandle * );
  244. void GetDefList(struct MPGuiHandle * );
  245. void GetDefMList(struct MPGuiHandle * );
  246. void GetDefLines(struct MPGuiHandle * );
  247. void GetCycleTitle(struct MPGuiHandle * );
  248. void GetCycleParameter(struct MPGuiHandle * );
  249. void GetListTitle(struct MPGuiHandle * );
  250. void GetListParameter(struct MPGuiHandle * );
  251. void GetListNParameter(struct MPGuiHandle * );
  252. unsigned char * SkipSpace(unsigned char * );
  253. void RequesterStuff(struct MPGuiHandle *);
  254. BOOL CreateGadgets(struct MPGuiHandle *);
  255. static void checkleft(struct MPGuiHandle *gh, int addheight, short *curgh, int *tleft);
  256. BOOL GetAFile(struct MPGuiHandle * , UBYTE const * , unsigned char const * , ULONG ,char *);
  257. BOOL GetAMode(struct MPGuiHandle *, struct MyGadget * , UBYTE const * , unsigned char const *);
  258. BOOL GetAFont(struct MPGuiHandle *, struct MyGadget * , UBYTE const * , unsigned char const *);
  259. void GetHelp(struct MPGuiHandle * );
  260. void DisableWindow(struct MPGuiHandle *gh);
  261. void EnableWindow(struct MPGuiHandle *gh);
  262. ULONG MyCallHookPkt(struct MPGuiHandle *gh,struct Hook *,APTR,APTR);
  263. ULONG __asm MyRefresh(register __a0 struct Hook *hook,
  264.                                   register __a2 struct FileRequester *fr,
  265.                                   register __a1 struct IntuiMessage *msg);
  266.  
  267.  
  268. /****** MPGui.library/AllocMPGuiHandleA *************************************
  269. *
  270. *   NAME   
  271. *  AllocMPGuiHandleA -- Allocates an MPGuiHandle. (V3)
  272. *  AllocMPGuiHandle -- Varargs version of AllocMPGuiHandleA (V3)
  273. *
  274. *   SYNOPSIS
  275. *  gh = AllocMPGuiHandleA(taglist)
  276. *  D0                     A0
  277. *
  278. *  struct MPGuiHandle * AllocMPGuiHandleA(struct TagItem *);
  279. *
  280. *  gh = AllocMPGuiHandle(Tag1, ...)
  281. *
  282. *  struct MPGuiHandle * AllocMPGuiHandle(ULONG,...);
  283. *
  284. *   FUNCTION
  285. *  Allocates an MPGuiHandle.
  286. *
  287. *   INPUTS
  288. *  taglist - pointer to TagItem array.
  289. *
  290. *  Tags are:
  291. *
  292. *  MPG_PUBSCREENNAME - Data is char * name of public screen to use.
  293. *                      Default is default public screen.
  294. *  MPG_RELMOUSE      - Data is BOOL. TURE to open requester near pointer.
  295. *                      Default is FALSE.
  296. *  MPG_HELP          - Data is struct Hook *, called with object=char * to
  297. *                      help node to be displayed.
  298. *  MPG_CHELP         - Call help when gadget changes
  299. *  MPG_PARAMS        - Data is char ** array of parameters
  300. *  MPG_NEWLINE       - Data is BOOL. TRUE means new line rather than space
  301. *                      in output, no "s round files or screen modes.
  302. *                      Default is FALSE.
  303. *  MPG_PREFS         - Data is BOOL. Default FALSE. TRUE provides
  304. *                      _Save/_Use/_Cancel gadgets, Use MPGuiResponse() to
  305. *                      get response (1=Save 2=Use), Esc key will not exit.
  306. *  MPG_MENUS         - Data is struct NewMenu *.
  307. *  MPG_MENUHOOK      - Data is struct Hook *, called with
  308. *                      object=struct IntuiMsg *, message = struct Menu *
  309. *                      If MPG_HELP is set then called for MENUHELP as well.
  310. *                      Return 0 to quit, non 0 to continue.
  311. *  MPG_SIGNALS       - Data is ULONG signals to wait for then call hook
  312. *                      provided in MPG_SIGNALHOOK.
  313. *  MPG_SIGNALHOOK    - Data is struct Hook *, called with
  314. *                      object = ULONG signals received,
  315. *                      message = ULONG notused
  316. *                      Return 0 to quit, non 0 to continue.
  317. *  MPG_CHECKMARK     - Data is struct Image * for menu checkmark
  318. *  MPG_AMIGAKEY      - Data is struct Image * for menu AmigaKey
  319. *  MPG_BUTTONHOOK        - Data is struct Hook *,
  320. *                      called with object=struct MPGuiHandle *,
  321. *                      message = number of button
  322. *                      Return 0 to quit, non 0 to continue.
  323. *  MPG_NOBUTTONS     - If set then no buttons are shown, overrides MPG_PREFS.
  324. *
  325. *   RESULT
  326. *  gh - Allocated MPGuiHandle.
  327. *       NULL on error (no memory).
  328. *
  329. *   EXAMPLE
  330. *
  331. *   NOTES
  332. *
  333. *   BUGS
  334. *  The allocated handle has a max size of about 3K for the response.
  335. *  The maximum parameter replaced line length is about 2K.
  336. *  FONT? gadgets ignore the size at the moment.
  337. *  If there are more than 3 BUTTON gadgets in a row then they are left
  338. *  justified - should be fully justified.
  339. *  Button layout may not yet be correct.
  340. *
  341. *   SEE ALSO
  342. *  FreeMPGuiHandle(),MPGuiResponse().
  343. *
  344. *****************************************************************************
  345. *
  346. */
  347. // Allocate a handle
  348. struct MPGuiHandle *__saveds __asm
  349. AllocMPGuiHandleA(register __a0 struct TagItem *TagList) {
  350.     struct MPGuiHandle *gh;
  351.  
  352.     if (gh = (struct MPGuiHandle *)AllocMem(sizeof(struct MPGuiHandle),MEMF_ANY | MEMF_CLEAR)) {
  353.         gh->TagList = CloneTagItems(TagList);
  354.         if (gh->MemPool = CreatePool(MEMF_CLEAR | MEMF_ANY,2048,1024)) {
  355.             if (gh->filereq = AllocFileRequest()) {
  356.                 gh->RefreshHook.h_Entry = (HOOKFUNC)MyRefresh;
  357.                 gh->RefreshHook.h_Data = gh;
  358.                 return gh;
  359.             }
  360.             DeletePool(gh->MemPool);
  361.         }
  362.         FreeMem(gh,sizeof(struct MPGuiHandle));
  363.     }
  364.     return NULL;
  365. }
  366.  
  367. /****** MPGui.library/FreeMPGuiHandle ****************************************
  368. *
  369. *   NAME   
  370. *  FreeMPGuiHandle -- Frees a Handle allocated by AllocMPGuiHandleA(). (V3)
  371. *
  372. *   SYNOPSIS
  373. *  FreeMPGuiHandle( gh)
  374. *                   A0
  375. *
  376. *  void FreeMPGuiHandle( struct MPGuiHandle *);
  377. *
  378. *
  379. *   FUNCTION
  380. *  Frees a Handle allocated by AllocMPGuiHandleA().
  381. *
  382. *   INPUTS
  383. *  gh - Handle allocated by AllocMPGuiHandleA.
  384. *
  385. *   RESULT
  386. *  None.
  387. *
  388. *   EXAMPLE
  389. *
  390. *   NOTES
  391. *
  392. *   BUGS
  393. *
  394. *   SEE ALSO
  395. *  AllocMPGuiHandleA().
  396. *
  397. *****************************************************************************
  398. *
  399. */
  400. // Free a handle
  401. __saveds __asm void
  402. FreeMPGuiHandle(register __a0 struct MPGuiHandle *gh) {
  403.     if (gh) {
  404.         if (gh->TagList) {
  405.             FreeTagItems(gh->TagList);
  406.         }
  407.         if (gh->filereq) {
  408.             FreeAslRequest(gh->filereq);
  409.         }
  410.         if (gh->MemPool) {
  411.             DeletePool(gh->MemPool);
  412.         }
  413.         FreeMem(gh,sizeof(struct MPGuiHandle));
  414.     }
  415. }
  416.     
  417. /****** MPGui.library/MPGuiError *********************************************
  418. *
  419. *   NAME   
  420. *  MPGuiError -- Returns the error message for an MPGuiHandle. (V3)
  421. *
  422. *   SYNOPSIS
  423. *  Message = MPGuiError(gh )
  424. *  D0                   A0
  425. *
  426. *  char * MPGuiError( struct MPGuiHandle *);
  427. *
  428. *   FUNCTION
  429. *  Returns the error message for an MPGuiHandle.
  430. *
  431. *   INPUTS
  432. *  gh - MPGuiHandle allocated by AllocMPGuiHandleA().
  433. *
  434. *   RESULT
  435. *  Message - The text of an error message. May be multi line.
  436. *
  437. *   EXAMPLE
  438. *
  439. *   NOTES
  440. *  Use after SyncMPGuiRequest() returns -1.
  441. *
  442. *   BUGS
  443. *
  444. *   SEE ALSO
  445. *  SyncMPGuiRequest().
  446. *
  447. ******************************************************************************
  448. *
  449. */
  450. __saveds __asm char *
  451. MPGuiError(register __a0 struct MPGuiHandle *gh) {
  452.     return gh->error;
  453. }
  454.  
  455. /****** MPGui.library/MPGuiResponse ******************************************
  456. *
  457. *   NAME   
  458. *  MPGuiResponse -- returns the response from a Prefs MPGui. (V3)
  459. *
  460. *   SYNOPSIS
  461. *  resp = MPGuiResponse( gh)
  462. *  D0                   A0
  463. *
  464. *  ULONG MPGuiResponse( struct MPGuiHandle *);
  465. *
  466. *   FUNCTION
  467. *  Returns the response after calling SyncMPGuiRequest() with MPG_PREFS.
  468. *
  469. *   INPUTS
  470. *  gh - An MPGuiHandle.
  471. *
  472. *   RESULT
  473. *  resp - MPG_SAVE Save gadget was pressed.
  474. *         MPG_USE  Use gadget was pressed.
  475. *
  476. *   EXAMPLE
  477. *
  478. *   NOTES
  479. *  Only use if SyncMPGui() returns not (0 or -1).
  480. *
  481. *   BUGS
  482. *
  483. *   SEE ALSO
  484. *  AllocMPGuiHandleA(),SyncMPGuiRequest().
  485. *
  486. *****************************************************************************
  487. *
  488. */
  489. __saveds __asm ULONG
  490. MPGuiResponse(register __a0 struct MPGuiHandle *gh) {
  491.     return gh->Response;
  492. }
  493.  
  494. /****** MPGui.library/MPGuiCurrentAttrs *************************************
  495. *
  496. *   NAME   
  497. *  MPGuiCurrentAttrs -- Returns the Current MPGui attributes. (V3)
  498. *
  499. *   SYNOPSIS
  500. *  Attrs = MPGuiCurrentAttrs( gh)
  501. *  D0                          A0
  502. *
  503. *  char * MPGuiCurrentAttrs( struct MPGuiHandle *);
  504. *
  505. *   FUNCTION
  506. *  Returns the same as would be returned by SyncMPGuiRequest if the OK gadget
  507. *  is pressed now.
  508. *
  509. *   INPUTS
  510. *  gh - An MPGuiHandle currently being used by SyncMPGuiRequest().
  511. *
  512. *   RESULT
  513. *  Attrs - String that would be returned SyncMPGuiRequest.
  514. *
  515. *   EXAMPLE
  516. *
  517. *   NOTES
  518. *  This should be called from a MPG_MENUHOOK supplied to AllocMPGuiHandle().
  519. *  e.g. If a Save As... menu item is called.
  520. *
  521. *   BUGS
  522. *
  523. *   SEE ALSO
  524. *  SyncMPGuiRequest().
  525. *
  526. *****************************************************************************
  527. *
  528. */
  529. __saveds __asm char *
  530. MPGuiCurrentAttrs(register __a0 struct MPGuiHandle *gh) {
  531.     struct MyGadget *LoopGadget;
  532.     int count;
  533.     struct MyValue *MyValue;
  534.     char *p = NULL;
  535.     ULONG l = 0;
  536.     char buffer[32];
  537.  
  538.     sprintf(gh->result,"%s",gh->Command);
  539.     if (gh->NewLine) {
  540.         strcat(gh->result,"\n");
  541.     }
  542.     for (LoopGadget = (struct MyGadget *)(gh->GList.lh_Head);
  543.             LoopGadget->GNode.ln_Succ;
  544.             LoopGadget = (struct MyGadget *)(LoopGadget->GNode.ln_Succ)) {
  545.         if (!LoopGadget->OwnCycle || (LoopGadget->OwnCycle->Currenty == LoopGadget->Activey)) {
  546.             switch (LoopGadget->Type) {
  547.             case GAD_FILE:
  548.             case GAD_LFILE:
  549.             case GAD_SFILE:
  550.                 GT_GetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  551.                                     GTST_String,&p,
  552.                                     TAG_END);
  553.                 if (strstr(LoopGadget->Prefix,"%s")) {
  554.                     sprintf(gh->tBuffer,LoopGadget->Prefix,p);
  555.                 }
  556.                 else {
  557.                     if (gh->NewLine) {
  558.                         sprintf(gh->tBuffer,"%s%s",LoopGadget->Prefix,p);
  559.                     }
  560.                     else {
  561.                         sprintf(gh->tBuffer,"%s\"%s\"",LoopGadget->Prefix,p);
  562.                     }
  563.                 }
  564.                 strcat(gh->result,gh->tBuffer);
  565.                 break;
  566.             case GAD_MODE:
  567.             case GAD_FONT:
  568.                 GT_GetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  569.                                     GTTX_Text,&p,
  570.                                     TAG_END);
  571.                 if (strstr(LoopGadget->Prefix,"%s")) {
  572.                     sprintf(gh->tBuffer,LoopGadget->Prefix,p);
  573.                 }
  574.                 else {
  575.                     if (gh->NewLine) {
  576.                         sprintf(gh->tBuffer,"%s%s",LoopGadget->Prefix,p);
  577.                     }
  578.                     else {
  579.                         sprintf(gh->tBuffer,"%s\"%s\"",LoopGadget->Prefix,p);
  580.                     }
  581.                 }
  582.                 strcat(gh->result,gh->tBuffer);
  583.                 break;
  584.             case GAD_OMODE:
  585.             case GAD_OFONT:
  586.                 if (LoopGadget->Currentc) {
  587.                     GT_GetGadgetAttrs(LoopGadget->Gadget2,gh->Window,NULL,
  588.                                         GTTX_Text,&p,
  589.                                         TAG_END);
  590.                     if (strstr(LoopGadget->Prefix,"%s")) {
  591.                         sprintf(gh->tBuffer,LoopGadget->Prefix,p);
  592.                     }
  593.                     else {
  594.                         if (gh->NewLine) {
  595.                             sprintf(gh->tBuffer,"%s%s",LoopGadget->Prefix,p);
  596.                         }
  597.                         else {
  598.                             sprintf(gh->tBuffer,"%s\"%s\"",LoopGadget->Prefix,p);
  599.                         }
  600.                     }
  601.                     strcat(gh->result,gh->tBuffer);
  602.                 }
  603.                 break;
  604.             case GAD_OFILE:
  605.                 if (LoopGadget->Currentc) {
  606.                     GT_GetGadgetAttrs(LoopGadget->Gadget2,gh->Window,NULL,
  607.                                         GTST_String,&p,
  608.                                         TAG_END);
  609.                     if (strstr(LoopGadget->Prefix,"%s")) {
  610.                         sprintf(gh->tBuffer,LoopGadget->Prefix,p);
  611.                     }
  612.                     else {
  613.                         if (gh->NewLine) {
  614.                             sprintf(gh->tBuffer,"%s%s",LoopGadget->Prefix,p);
  615.                         }
  616.                         else {
  617.                             sprintf(gh->tBuffer,"%s\"%s\"",LoopGadget->Prefix,p);
  618.                         }
  619.                     }
  620.                     strcat(gh->result,gh->tBuffer);
  621.                 }
  622.                 break;
  623.             case GAD_ONUMBER:
  624.                 if (LoopGadget->Currentc) {
  625.                     GT_GetGadgetAttrs(LoopGadget->Gadget2,gh->Window,NULL,
  626.                                     GTIN_Number,&l,
  627.                                     TAG_END);
  628.                     if (strstr(LoopGadget->Prefix,"%s")) {
  629.                         sprintf(buffer,"%ld",l);
  630.                         sprintf(gh->tBuffer,LoopGadget->Prefix,buffer);
  631.                     }
  632.                     else {
  633.                         sprintf(gh->tBuffer,"%s%ld",LoopGadget->Prefix,l);
  634.                     }
  635.                     strcat(gh->result,gh->tBuffer);
  636.                 }
  637.                 break;
  638.             case GAD_NUMBER:
  639.                 GT_GetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  640.                                 GTIN_Number,&l,
  641.                                 TAG_END);
  642.                 if (strstr(LoopGadget->Prefix,"%s")) {
  643.                     sprintf(buffer,"%ld",l);
  644.                     sprintf(gh->tBuffer,LoopGadget->Prefix,buffer);
  645.                 }
  646.                 else {
  647.                     sprintf(gh->tBuffer,"%s%ld",LoopGadget->Prefix,l);
  648.                 }
  649.                 strcat(gh->result,gh->tBuffer);
  650.                 break;
  651.             case GAD_CYCLE:
  652.             case GAD_LIST:
  653.                 count = 0;
  654.                 for (MyValue = (struct MyValue *)(LoopGadget->VList.lh_Head);
  655.                         MyValue->VNode.ln_Succ;
  656.                         MyValue = (struct MyValue *)(MyValue->VNode.ln_Succ)){
  657.                     if (count == LoopGadget->Currenty) {
  658.                         strcat(gh->result,MyValue->Prefix);
  659.                     }
  660.                     ++count;
  661.                 }
  662.                 break;
  663.             case GAD_MLIST:
  664.                 for (MyValue = (struct MyValue *)(LoopGadget->VList.lh_Head);
  665.                         MyValue->VNode.ln_Succ;
  666.                         MyValue = (struct MyValue *)(MyValue->VNode.ln_Succ)){
  667.                     if (MyValue->Selected) {
  668.                         strcat(gh->result,MyValue->Prefix);
  669.                         if (gh->NewLine) {
  670.                             strcat(gh->result,"\n");
  671.                         }
  672.                         else {
  673.                             strcat(gh->result," ");
  674.                         }
  675.                     }
  676.                     else {
  677.                         if (MyValue->NPrefix) {
  678.                             strcat(gh->result,MyValue->NPrefix);
  679.                             if (gh->NewLine) {
  680.                                 strcat(gh->result,"\n");
  681.                             }
  682.                             else {
  683.                                 strcat(gh->result," ");
  684.                             }
  685.                         }
  686.                     }
  687.                 }
  688.                 break;
  689.             case GAD_STRING:
  690.                 GT_GetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  691.                                     GTST_String,&p,
  692.                                     TAG_END);
  693.                 if (strstr(LoopGadget->Prefix,"%s")) {
  694.                     sprintf(gh->tBuffer,LoopGadget->Prefix,p);
  695.                 }
  696.                 else {
  697.                     sprintf(gh->tBuffer,"%s%s",LoopGadget->Prefix,p);
  698.                 }
  699.                 strcat(gh->result,gh->tBuffer);
  700.                 break;
  701.             case GAD_OSTRING:
  702.                 if (LoopGadget->Currentc) {
  703.                     GT_GetGadgetAttrs(LoopGadget->Gadget2,gh->Window,NULL,
  704.                                         GTST_String,&p,
  705.                                         TAG_END);
  706.                     if (strstr(LoopGadget->Prefix,"%s")) {
  707.                         sprintf(gh->tBuffer,LoopGadget->Prefix,p);
  708.                     }
  709.                     else {
  710.                         sprintf(gh->tBuffer,"%s%s",LoopGadget->Prefix,p);
  711.                     }
  712.                     strcat(gh->result,gh->tBuffer);
  713.                 }
  714.                 break;
  715.             case GAD_CHECK:
  716.                 if (LoopGadget->Currentc) {
  717.                     strcat(gh->result,LoopGadget->Prefix);
  718.                 }
  719.                 else {
  720.                     if (LoopGadget->NPrefix) {
  721.                         strcat(gh->result,LoopGadget->NPrefix);
  722.                     }
  723.                 }
  724.                 break;
  725.             case GAD_SLIDER:
  726.                 if (strstr(LoopGadget->Prefix,"%s")) {
  727.                     sprintf(buffer,"%ld",LoopGadget->Currentn);
  728.                     sprintf(gh->tBuffer,LoopGadget->Prefix,buffer);
  729.                 }
  730.                 else {
  731.                     sprintf(gh->tBuffer,"%s%ld",LoopGadget->Prefix,LoopGadget->Currentn);
  732.                 }
  733.                 strcat(gh->result,gh->tBuffer);
  734.                 break;
  735.             case GAD_BUTTON:
  736.                 break;
  737.             case GAD_BUTTONTEXT:
  738.                 break;
  739.             }
  740.             if (gh->NewLine) {
  741.                 strcat(gh->result,"\n");
  742.             }
  743.             else {
  744.                 strcat(gh->result," ");
  745.             }
  746.         }
  747.     }
  748.     // convert " back
  749.     p = gh->result;
  750.     while (*p) {
  751.         if ('\001' == *p) {
  752.             *p = '"';
  753.         }
  754.         ++p;
  755.     }
  756.     return gh->result;
  757. }
  758.  
  759. /****** MPGui.library/SetMPGuiGadgetValue ***********************************
  760. *
  761. *   NAME   
  762. *  SetMPGuiGadgetValue -- Sets the value of an MPGui gadget. (V3)
  763. *
  764. *   SYNOPSIS
  765. *  succ = SetMPGuiGadgetValue( gh, Title, Value)
  766. *  D0                          A0  A1     A2
  767. *
  768. *  BOOL SetMPGuiGadgetValue( struct MPGuiHandle *, char *, char *);
  769. *
  770. *   FUNCTION
  771. *  Sets the value of a gadget currently being displayed by
  772. *  SyncMPGuiRequest().
  773. *
  774. *   INPUTS
  775. *  gh    - MPGuiHandle being displayed by SyncMPGuiRequest().
  776. *  Title - Title of the gadget as in the input file.
  777. *  Value - Value of the gadget.
  778. *          Y/N for a CHECKs.
  779. *          A String for Strings/Files/Modes.
  780. *          A String (which is converted using strtol) for Numbers/Sliders.
  781. *          A value or number in the list/cycle for lists/cycles.
  782. *          Values strung together sperated by space for an MLIST gadget
  783. *
  784. *   RESULT
  785. *  error - 1 for success, 0 for failure.
  786. *          Error means gadget not found or Value not found.
  787. *
  788. *   EXAMPLE
  789. *
  790. *   NOTES
  791. *  Title must be exact including "_" as required.
  792. *
  793. *  This should be called from a MPG_MENUHOOK supplied to AllocMPGuiHandle().
  794. *  e.g. If a Reset To Defaults... menu item is called.
  795. *
  796. *  BUTTON gadgets can not have there attributes set.
  797. *
  798. *   BUGS
  799. *  For an MLIST gadget if a value is a substring of another gadget then the
  800. *  value can be incorrectly set.
  801. *
  802. *  MTEXT/TEXT gadgets can not be updated.
  803. *
  804. *   SEE ALSO
  805. *  SyncMPGuiRequest().
  806. *
  807. *****************************************************************************
  808. *
  809. */
  810. __saveds __asm BOOL
  811. SetMPGuiGadgetValue(register __a0 struct MPGuiHandle *gh,
  812.                             register __a1 char *Title, register __a2 char *Value) {
  813.     struct MyGadget *LoopGadget,*Loop1Gadget;
  814.     BOOL Ok = FALSE;
  815.     int i;
  816.     int number;
  817.     struct MyValue *MyValue;
  818.     char *s;
  819.  
  820.     for (LoopGadget = (struct MyGadget *)(gh->GList.lh_Head);
  821.                                         LoopGadget->GNode.ln_Succ;
  822.                                         LoopGadget = (struct MyGadget *)(LoopGadget->GNode.ln_Succ)) {
  823.         if (!strcmp(LoopGadget->Title,Title)) {
  824.             switch (LoopGadget->Type) {
  825.             case GAD_LFILE:
  826.             case GAD_SFILE:
  827.             case GAD_FILE:
  828.             case GAD_STRING:
  829.                 Ok = TRUE;
  830.                 GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  831.                                     GTST_String,Value,
  832.                                     TAG_END);
  833.                 break;
  834.             case GAD_MODE:
  835.             case GAD_FONT:
  836.                 Ok = TRUE;
  837.                 GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  838.                                     GTTX_Text,Value,
  839.                                     TAG_END);
  840.                 break;
  841.             case GAD_OMODE:
  842.             case GAD_OFONT:
  843.                 Ok = TRUE;
  844.                 GT_SetGadgetAttrs(LoopGadget->Gadget2,gh->Window,NULL,
  845.                                     GTTX_Text,Value,
  846.                                     TAG_END);
  847.                 break;
  848.             case GAD_NUMBER:
  849.                 Ok = TRUE;
  850.                 GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  851.                                     GTIN_Number,strtol(Value,NULL,10),
  852.                                     TAG_END);
  853.                 break;
  854.             case GAD_ONUMBER:
  855.                 Ok = TRUE;
  856.                 GT_SetGadgetAttrs(LoopGadget->Gadget2,gh->Window,NULL,
  857.                                     GTIN_Number,strtol(Value,NULL,10),
  858.                                     TAG_END);
  859.                 break;
  860.             case GAD_CYCLE:
  861.                 i = 0;
  862.                 number = -1;
  863.                 for (MyValue = (struct MyValue *)(LoopGadget->VList.lh_Head);
  864.                         MyValue->VNode.ln_Succ;
  865.                         MyValue = (struct MyValue *)(MyValue->VNode.ln_Succ)){
  866.                     if (!strcmp(Value,MyValue->VNode.ln_Name)) {
  867.                         number = i;
  868.                     }
  869.                     ++i;
  870.                 }
  871.                 if (number == -1) {
  872.                     number = strtol(Value,NULL,10);
  873.                 }
  874.                 if (number != -1) {
  875.                     Ok = TRUE;
  876.                     LoopGadget->Currenty = number;
  877.                     GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  878.                                 GTCY_Active, LoopGadget->Currenty,
  879.                                 TAG_END);
  880.                     for (Loop1Gadget = (struct MyGadget *)(gh->GList.lh_Head);
  881.                             Loop1Gadget->GNode.ln_Succ;
  882.                             Loop1Gadget = (struct MyGadget *)(Loop1Gadget->GNode.ln_Succ)){
  883.                         if (LoopGadget == Loop1Gadget->OwnCycle) {
  884.                             GT_SetGadgetAttrs(Loop1Gadget->Gadget1,gh->Window,NULL,
  885.                                                     GA_Disabled,LoopGadget->Currenty != Loop1Gadget->Activey,
  886.                                                     TAG_END);
  887.                             if (Loop1Gadget->Gadget2) {
  888.                                 GT_SetGadgetAttrs(Loop1Gadget->Gadget2,gh->Window,NULL,
  889.                                         GA_Disabled,(LoopGadget->Currenty != Loop1Gadget->Activey) ||
  890.                                                         (((Loop1Gadget->Type == GAD_ONUMBER) ||
  891.                                                           (Loop1Gadget->Type == GAD_OSTRING) ||
  892.                                                           (Loop1Gadget->Type == GAD_OFILE)) && (!Loop1Gadget->Currentc)),
  893.                                         TAG_END);
  894.                             }
  895.                             if (Loop1Gadget->Gadget3) {
  896.                                 GT_SetGadgetAttrs(Loop1Gadget->Gadget3,gh->Window,NULL,
  897.                                         GA_Disabled,(LoopGadget->Currenty != Loop1Gadget->Activey) ||
  898.                                                           (((Loop1Gadget->Type == GAD_OFILE) ||
  899.                                                             (Loop1Gadget->Type == GAD_OMODE) ||
  900.                                                             (Loop1Gadget->Type == GAD_OFONT))
  901.                                                             && (!Loop1Gadget->Currentc)),
  902.                                         TAG_END);
  903.                             }
  904.                         }
  905.                     }
  906.                 }
  907.                 break;
  908.             case GAD_LIST:
  909.                 i = 0;
  910.                 number = -1;
  911.                 for (MyValue = (struct MyValue *)(LoopGadget->VList.lh_Head);
  912.                         MyValue->VNode.ln_Succ;
  913.                         MyValue = (struct MyValue *)(MyValue->VNode.ln_Succ)){
  914.                     if (!strcmp(Value,MyValue->VNode.ln_Name)) {
  915.                         number = i;
  916.                     }
  917.                     ++i;
  918.                 }
  919.                 if (number == -1) {
  920.                     number = strtol(Value,NULL,10);
  921.                 }
  922.                 if (number != -1) {
  923.                     Ok = TRUE;
  924.                     LoopGadget->Currenty = number;
  925.                     GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  926.                                 GTLV_Selected, LoopGadget->Currenty,
  927.                                 GTLV_MakeVisible, LoopGadget->Currenty,
  928.                                 TAG_END);
  929.                 }
  930.                 break;
  931.             case GAD_MLIST:
  932.                 GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  933.                                     GTLV_Labels, -1,
  934.                                     TAG_END);
  935.                 for (MyValue = (struct MyValue *)(LoopGadget->VList.lh_Head);
  936.                         MyValue->VNode.ln_Succ;
  937.                         MyValue = (struct MyValue *)(MyValue->VNode.ln_Succ)) {
  938.                     if (s = strstr(Value,MyValue->VNode.ln_Name)) {
  939.                         MyValue->Selected = TRUE;
  940.                     }
  941.                     else {
  942.                         MyValue->Selected = FALSE;
  943.                     }
  944.                 }
  945.                 GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  946.                                     GTLV_Labels, &(LoopGadget->VList),
  947.                                     TAG_END);
  948.                 break;
  949.             case GAD_OFILE:
  950.             case GAD_OSTRING:
  951.                 Ok = TRUE;
  952.                 GT_SetGadgetAttrs(LoopGadget->Gadget2,gh->Window,NULL,
  953.                                     GTST_String,Value,
  954.                                     TAG_END);
  955.                 break;
  956.             case GAD_CHECK:
  957.                 Ok = TRUE;
  958.                 GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  959.                                     GTCB_Checked, LoopGadget->Currentc = (toupper(*Value) == 'Y'),
  960.                                     TAG_END);
  961.                 break;
  962.             case GAD_SLIDER:
  963.                 Ok = TRUE;
  964.                 LoopGadget->Currentn = strtol(Value,NULL,10);
  965.                 GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  966.                                 GTSL_Level, LoopGadget->Currentn,
  967.                                 TAG_END);
  968.                 break;
  969.             case GAD_BUTTON:
  970.                 break;
  971.             case GAD_BUTTONTEXT:
  972.                 break;
  973.             default:
  974.                 break;
  975.             }
  976.         }
  977.     }
  978.     return Ok;
  979. }
  980.  
  981. /****** MPGui.library/SyncMPGuiRequest **************************************
  982. *
  983. *   NAME   
  984. *  SyncMPGuiRequest -- Displays and processes an MPGui. (V3)
  985. *
  986. *   SYNOPSIS
  987. *  result = SyncMPGuiRequest( fname, gh)
  988. *  D0                         A0     A1
  989. *
  990. *  char * SyncMPGuiRequest( char *, struct MPGuiHandle *);
  991. *
  992. *   FUNCTION
  993. *  Displays an MPGuiHandle allocated by AllocMPGuiHandle() and processes all
  994. *  messages.
  995. *
  996. *   INPUTS
  997. *  fname - name of file describing gui.
  998. *  gh    - MPGuiHandle allocated by AllocMPGuiHandle().
  999. *
  1000. *   RESULT
  1001. *  Attributes of the MPGui if Save/Use/Ok was used.
  1002. *  0 if Cancel was used/window closed/Esc pressed.
  1003. *  -1 for error. Use MPGuiError() to get error.
  1004. *
  1005. *   EXAMPLE
  1006. *
  1007. *   NOTES
  1008. *  If MPG_PREFS was supplied to AllocMPGuiHandle() then use MPGuiResponse()
  1009. *  to determine if Save or Use was pressed.
  1010. *
  1011. *  If the requester will not fit in one column with the default screen font
  1012. *  then it falls back in the following order until it fits:
  1013. *
  1014. *    Compressed vertical seperation;
  1015. *    Default fixed font;
  1016. *    Default fixed font with compressed vertical seperation;
  1017. *    Topaz 80;
  1018. *    Topaz 80 with compressed vertical seperation;
  1019. *    Two columns topaz 80 with compressed vertical seperation;
  1020. *    3 or more columns topaz 80 with compressed vertical seperation.
  1021. *
  1022. *   BUGS
  1023. *  When trying to cope with very small screens/very large requesters it can
  1024. *  result in gadgets with negative width which can crash the system. This
  1025. *  should only happen if more than 2 columns are required.
  1026. *
  1027. *  Fixed in version 5.1 Buttons with no Title going to a new column
  1028. *
  1029. *   SEE ALSO
  1030. *  AllocMPGuiHandleA(),MPGuiError(),MPGuiResponse().
  1031. *
  1032. *****************************************************************************
  1033. *
  1034. */
  1035. char * __saveds __asm
  1036. SyncMPGuiRequest(register __a0 char *fname,register __a1 struct MPGuiHandle *gh) {
  1037.     UBYTE *temp = 0;
  1038.     struct TagItem *ti;
  1039.     if (!fname || !gh) {
  1040.         pError(gh,GetMessage(MSG_ERR_NOPS),NULL);
  1041.         return (char *) -1;
  1042.     }
  1043.     if (ti = FindTagItem(MPG_AMIGAKEY,gh->TagList)) {
  1044.         gh->Amiga = (struct Image *)ti->ti_Data;
  1045.     }
  1046.     if (ti = FindTagItem(MPG_CHECKMARK,gh->TagList)) {
  1047.         gh->Check = (struct Image *)ti->ti_Data;
  1048.     }
  1049.     if (ti = FindTagItem(MPG_PUBSCREENNAME,gh->TagList)) {
  1050.         temp = (UBYTE *)(ti->ti_Data);
  1051.     }
  1052.     if (!(gh->MyScreen = LockPubScreen(temp))) {
  1053.         gh->MyScreen = LockPubScreen(NULL);
  1054.     }
  1055.     if (ti = FindTagItem(MPG_HELP,gh->TagList)) {
  1056.         gh->HelpFunc = (struct Hook *)(ti->ti_Data);
  1057.     }
  1058.     if (ti = FindTagItem(MPG_CHELP,gh->TagList)) {
  1059.         gh->CHelp = ti->ti_Data;
  1060.     }
  1061.     if (ti = FindTagItem(MPG_PARAMS,gh->TagList)) {
  1062.         gh->Params = (char **)ti->ti_Data;
  1063.     }
  1064.     if (ti = FindTagItem(MPG_NEWLINE,gh->TagList)) {
  1065.         gh->NewLine = ti->ti_Data;
  1066.     }
  1067.     if (ti = FindTagItem(MPG_PREFS,gh->TagList)) {
  1068.         gh->Prefs = ti->ti_Data;
  1069.     }
  1070.     if (ti = FindTagItem(MPG_NOBUTTONS,gh->TagList)) {
  1071.         gh->NoButtons = ti->ti_Data;
  1072.         if (gh->NoButtons) {
  1073.             gh->Prefs = FALSE;
  1074.         }
  1075.     }
  1076.     if (ti = FindTagItem(MPG_BUTTONHOOK,gh->TagList)) {
  1077.         gh->ButtonFunc = (struct Hook *)ti->ti_Data;
  1078.     }
  1079.     if (ti = FindTagItem(MPG_MENUS,gh->TagList)) {
  1080.         gh->NewMenu = (struct NewMenu *)ti->ti_Data;
  1081.     }
  1082.     if (ti = FindTagItem(MPG_MENUHOOK,gh->TagList)) {
  1083.         gh->MenuFunc = (struct Hook *)ti->ti_Data;
  1084.     }
  1085.     else {
  1086.         gh->Menu = FALSE;
  1087.     }
  1088.     if (ti = FindTagItem(MPG_SIGNALHOOK,gh->TagList)) {
  1089.         if (ti->ti_Data) {
  1090.             gh->SignalFunc = (struct Hook *)ti->ti_Data;
  1091.             if (ti = FindTagItem(MPG_SIGNALS,gh->TagList)) {
  1092.                 gh->Signals = ti->ti_Data;
  1093.             }
  1094.         }
  1095.     }
  1096.     gh->MyTextAttr = gh->MyScreen->Font;
  1097.     if (gh->MyScreen) {
  1098.         if (gh->fp = Open(fname,MODE_OLDFILE)) {
  1099.             if (myfgets(gh)) {
  1100.                 if (gh->buffer[0] == '"') {
  1101.                     Command(gh);
  1102.                 }
  1103.                 else {
  1104.                     pError(gh,GetMessage(MSG_ERR_NOSQ),gh->buffer);
  1105.                 }
  1106.             }
  1107.             else {
  1108.                 pError(gh,GetMessage(MSG_ERR_NOCOM),NULL);
  1109.             }
  1110.         }
  1111.         else {
  1112.             pError(gh,GetMessage(MSG_ERR_OPENF),fname);
  1113.         }
  1114.     }
  1115.     else {
  1116.         pError(gh,GetMessage(MSG_ERR_LOCKS),NULL);
  1117.     }
  1118.     if (!gh->FoundError) {
  1119.         ULONG temp,temp1;
  1120.         if (gh->allsize > (gh->leftsize + gh->rightsize)) {
  1121.             gh->rightsize = gh->allsize - gh->leftsize;
  1122.         }
  1123.         if (gh->tallsize > (gh->tleftsize + gh->trightsize)) {
  1124.             gh->trightsize = gh->tallsize - gh->tleftsize;
  1125.         }
  1126.         temp = gh->MyScreen->WBorTop + gh->MyScreen->Font->ta_YSize + 1 + gh->MyScreen->WBorBottom -
  1127.              (INTERHEIGHT + 1) * gh->extralist;
  1128.         temp1 = gh->numlines+(gh->NoButtons?0:1)+(gh->HelpMessageB?1:0)+1;
  1129.         if (temp + (gh->MyScreen->Font->ta_YSize + 2 + INTERHEIGHT)*temp1 >
  1130.                                         gh->MyScreen->Height) {
  1131.             if (temp + (gh->MyScreen->Font->ta_YSize + 2 + (INTERHEIGHT/2))*temp1 >
  1132.                                             gh->MyScreen->Height) {
  1133.                 if (temp + (GfxBase->DefaultFont->tf_YSize + 2 + INTERHEIGHT)*temp1 >
  1134.                                                 gh->MyScreen->Height) {
  1135.                     if (temp + (GfxBase->DefaultFont->tf_YSize + 2 + INTERHEIGHT/2)*temp1 >
  1136.                                                     gh->MyScreen->Height) {
  1137.                         if (temp + (8 + 2 + INTERHEIGHT)*temp1 >
  1138.                                                         gh->MyScreen->Height) {
  1139.                             gh->interwidth = INTERWIDTH;
  1140.                             gh->interheight = (INTERHEIGHT/2);
  1141.                             gh->Attr.ta_Name = (STRPTR)"topaz.font";
  1142.                             gh->Attr.ta_YSize = 8;
  1143.                             gh->MyTextAttr = &(gh->Attr);
  1144.                             gh->leftsize = gh->tleftsize;
  1145.                             gh->rightsize = gh->trightsize;
  1146.                             gh->UseTopaz = TRUE;
  1147.                             gh->XSize = 8;
  1148.                             if (temp + (8 + 2 + INTERHEIGHT/2)*temp1 >
  1149.                                                                 gh->MyScreen->Height) {
  1150.                                 if ((gh->leftsize*2 + gh->rightsize*2 + (gh->interwidth * 2) +
  1151.                                       gh->MyScreen->WBorLeft + gh->MyScreen->WBorRight) > gh->MyScreen->Width) {
  1152.                                     gh->rightsize = (gh->MyScreen->Width - 2 * gh->leftsize - (gh->interwidth * 2) -
  1153.                                                           gh->MyScreen->WBorLeft - gh->MyScreen->WBorRight) / 2;
  1154.                                 }
  1155.                             }
  1156.                         }
  1157.                         else {
  1158.                             gh->interwidth = INTERWIDTH;
  1159.                             gh->interheight = INTERHEIGHT;
  1160.                             gh->Attr.ta_Name = (STRPTR)"topaz.font";
  1161.                             gh->Attr.ta_YSize = 8;
  1162.                             gh->MyTextAttr = &(gh->Attr);
  1163.                             gh->leftsize = gh->tleftsize;
  1164.                             gh->rightsize = gh->trightsize;
  1165.                             gh->UseTopaz = TRUE;
  1166.                             gh->XSize = 8;
  1167.                         }
  1168.                     }
  1169.                     else {
  1170.                         gh->interwidth = INTERWIDTH;
  1171.                         gh->interheight = (INTERHEIGHT/2);
  1172.                         gh->Attr.ta_Name = (STRPTR)GfxBase->DefaultFont->tf_Message.mn_Node.ln_Name;
  1173.                         gh->Attr.ta_YSize = GfxBase->DefaultFont->tf_YSize;
  1174.                         gh->MyTextAttr = &(gh->Attr);
  1175.                         gh->leftsize = (gh->tleftsize * GfxBase->DefaultFont->tf_XSize)/8;
  1176.                         gh->rightsize = (gh->trightsize * GfxBase->DefaultFont->tf_XSize)/8;
  1177.                         gh->UseTopaz = TRUE;
  1178.                         gh->XSize = GfxBase->DefaultFont->tf_XSize;
  1179.                     }
  1180.                 }
  1181.                 else {
  1182.                     gh->interwidth = INTERWIDTH;
  1183.                     gh->interheight = INTERHEIGHT;
  1184.                     gh->Attr.ta_Name = (STRPTR)GfxBase->DefaultFont->tf_Message.mn_Node.ln_Name;
  1185.                     gh->Attr.ta_YSize = GfxBase->DefaultFont->tf_YSize;
  1186.                     gh->MyTextAttr = &(gh->Attr);
  1187.                     gh->leftsize = (gh->tleftsize * GfxBase->DefaultFont->tf_XSize)/8;
  1188.                     gh->rightsize = (gh->trightsize * GfxBase->DefaultFont->tf_XSize)/8;
  1189.                     gh->UseTopaz = TRUE;
  1190.                     gh->XSize = GfxBase->DefaultFont->tf_XSize;
  1191.                 }
  1192.             }
  1193.             else {
  1194.                 gh->interwidth = INTERWIDTH;
  1195.                 gh->interheight = INTERHEIGHT/2;
  1196.             }
  1197.         }
  1198.         else {
  1199.             gh->interwidth = INTERWIDTH;
  1200.             gh->interheight = INTERHEIGHT;
  1201.         }
  1202.         RequesterStuff(gh);
  1203.     }
  1204.     if (gh->MyScreen) {
  1205.         UnlockPubScreen(NULL,gh->MyScreen);
  1206.     }
  1207.     if (gh->fp) {
  1208.         Close(gh->fp);
  1209.     }
  1210.     if (gh->FoundError) {
  1211.         return (char *)-1;
  1212.     }
  1213.     else {
  1214.         if (gh->result[0]) {
  1215.             return gh->result;
  1216.         }
  1217.         else {
  1218.             return NULL;
  1219.         }
  1220.     }
  1221. }
  1222.  
  1223. /****** MPGui.library/ReadMPGui *********************************************
  1224. *
  1225. *   NAME   
  1226. *  ReadMPGui -- Reads information for an MPGui. (V4)
  1227. *
  1228. *   SYNOPSIS
  1229. *  result = ReadMPGui( fname, gh)
  1230. *  D0                         A0     A1
  1231. *
  1232. *  BOOL ReadMPGui( char *, struct MPGuiHandle *);
  1233. *
  1234. *   FUNCTION
  1235. *  Reads all the information in the file for an MPGuiHandle allocated by
  1236. *  AllocMPGuiHandle().
  1237. *
  1238. *   INPUTS
  1239. *  fname - name of file describing gui.
  1240. *  gh    - MPGuiHandle allocated by AllocMPGuiHandle().
  1241. *
  1242. *   RESULT
  1243. *  TRUE if file read OK
  1244. *  FALSE for error. Use MPGuiError() to get error.
  1245. *
  1246. *   EXAMPLE
  1247. *
  1248. *   NOTES
  1249. *  Ignores any tags supplied to AllocMPGuiHandleA().
  1250. *
  1251. *  This currently serves no purpose, but may be later used for a gui based
  1252. *  gui designer.
  1253. *
  1254. *   BUGS
  1255. *
  1256. * Currently does nothing!
  1257. * Does not handle TEXT/MTEXT
  1258. *
  1259. *   SEE ALSO
  1260. *  AllocMPGuiHandleA(),MPGuiError(),WriteMPGui().
  1261. *
  1262. *****************************************************************************
  1263. *
  1264. */
  1265. BOOL __saveds __asm
  1266. ReadMPGui(register __a0 char *fname,register __a1 struct MPGuiHandle *gh) {
  1267. #if 0
  1268.     if (!fname || !gh) {
  1269.         pError(gh,GetMessage(MSG_ERR_NOPR),NULL);
  1270.         return FALSE;
  1271.     }
  1272.     if (gh->fp = Open(fname,MODE_OLDFILE)) {
  1273.         if (myfgets(gh)) {
  1274.             if (gh->buffer[0] == '"') {
  1275.                 Command(gh);
  1276.             }
  1277.             else {
  1278.                 pError(gh,GetMessage(MSG_ERR_NOSQ),gh->buffer);
  1279.             }
  1280.         }
  1281.         else {
  1282.             pError(gh,GetMessage(MSG_ERR_NOCOM),NULL);
  1283.         }
  1284.         Close(gh->fp);
  1285.     }
  1286.     else {
  1287.         pError(gh,GetMessage(MSG_ERR_OPENF),fname);
  1288.     }
  1289.     if (gh->FoundError) {
  1290.         return FALSE;
  1291.     }
  1292.     else {
  1293.         return TRUE;
  1294.     }
  1295. #else
  1296.     return TRUE;
  1297. #endif
  1298. }
  1299.  
  1300. #if 0
  1301. void
  1302. PrintHelp(struct MPGuiHandle *gh,struct MyGadget *gad) {
  1303.     if (gad->HelpNode) {
  1304.         if (gad->HelpMessage) {
  1305.             FPrintf(gh->fp,"!%s!%s!",gad->HelpNode,gad->HelpMessage);
  1306.         }
  1307.         else {
  1308.             FPrintf(gh->fp,"!%s!!",gad->HelpNode);
  1309.         }
  1310.     }
  1311.     else {
  1312.         if (gad->HelpMessage) {
  1313.             FPrintf(gh->fp,"!!%s!",gad->HelpMessage);
  1314.         }
  1315.         else {
  1316.             FPrintf(gh->fp,"!!!");
  1317.         }
  1318.     }
  1319. }
  1320.  
  1321. BOOL
  1322. PrintGadget(struct MPGuiHandle *gh,struct MyGadget *gad) {
  1323.     struct MyGadget *gad1;
  1324.     struct MyValue *val;
  1325.     int i,j;
  1326.     char *type;
  1327.     if (gad->OwnCycle) {
  1328.         FPuts(gh->fp,"\t\t");
  1329.     }
  1330.     else {
  1331.         FPutC(gh->fp,'\t');
  1332.     }
  1333.     switch (gad->Type) {
  1334.     case GAD_LFILE:
  1335.         type = "LFILE";
  1336.         break;
  1337.     case GAD_SFILE:
  1338.         type = "SFILE";
  1339.         break;
  1340.     case GAD_FILE:
  1341.         type = "FILE";
  1342.         break;
  1343.     case GAD_OFILE:
  1344.         type = "OFILE";
  1345.         break;
  1346.     case GAD_ONUMBER:
  1347.         type = "ONUMBER";
  1348.         break;
  1349.     case GAD_NUMBER:
  1350.         type = "NUMBER";
  1351.         break;
  1352.     case GAD_CYCLE:
  1353.         type = "CYCLE";
  1354.         break;
  1355.     case GAD_STRING:
  1356.         type = "STRING";
  1357.         break;
  1358.     case GAD_OSTRING:
  1359.         type = "OSTRING";
  1360.         break;
  1361.     case GAD_CHECK:
  1362.         type = "CHECK";
  1363.         break;
  1364.     case GAD_SLIDER:
  1365.         type = "SLIDER";
  1366.         break;
  1367.     case GAD_MODE:
  1368.         type = "MODE";
  1369.         break;
  1370.     case GAD_OMODE:
  1371.         type = "OMODE";
  1372.         break;
  1373.     case GAD_FONT:
  1374.         type = "FONT";
  1375.         break;
  1376.     case GAD_OFONT:
  1377.         type = "OFONT";
  1378.         break;
  1379.     case GAD_LIST:
  1380.         type = "LIST";
  1381.         break;
  1382.     case GAD_MLIST:
  1383.         type = "MLIST";
  1384.         break;
  1385.     case GAD_BUTTONTEXT:
  1386.         type = "BUTTON";
  1387.         break;
  1388.     case GAD_BUTTON:
  1389.         break;
  1390.     default:
  1391.         break;
  1392.     }
  1393.     switch (gad->Type) {
  1394.     case GAD_LFILE:
  1395.     case GAD_SFILE:
  1396.     case GAD_FILE:
  1397.     case GAD_STRING:
  1398.         FPrintf(gh->fp,"%s \"%s\":\"%s\":\"%s\"",type,gad->Title,gad->Prefix,gad->Defaults);
  1399.         PrintHelp(gh,gad);
  1400.         FPutC(gh->fp,'\n');
  1401.         break;
  1402.     case GAD_OFILE:
  1403.     case GAD_OSTRING:
  1404.         FPrintf(gh->fp,"%s \"%s\":\"%s\":\"%s\":%s",type,gad->Title,gad->Prefix,gad->Defaults,
  1405.                                                                     gad->Defaultc?"Y":"N");
  1406.         PrintHelp(gh,gad);
  1407.         FPutC(gh->fp,'\n');
  1408.         break;
  1409.     case GAD_ONUMBER:
  1410.         FPrintf(gh->fp,"%s \"%s\":\"%s\":\"%ld\":%s",type,gad->Title,gad->Prefix,gad->Defaultn,
  1411.                                                                     gad->Defaultc?"Y":"N");
  1412.         PrintHelp(gh,gad);
  1413.         FPutC(gh->fp,'\n');
  1414.         break;
  1415.     case GAD_NUMBER:
  1416.         FPrintf(gh->fp,"%s \"%s\":\"%s\":\"%ld\"",type,gad->Title,gad->Prefix,gad->Defaultn);
  1417.         PrintHelp(gh,gad);
  1418.         FPutC(gh->fp,'\n');
  1419.         break;
  1420.     case GAD_CYCLE:
  1421.         FPrintf(gh->fp,"%s \"%s\"",type,gad->Title);
  1422.         PrintHelp(gh,gad);
  1423.         FPutC(gh->fp,'\n');
  1424.         i = 0;
  1425.         for (gad1 = (struct MyGadget *)(gh->GList.lh_Head);
  1426.               gad1->GNode.ln_Succ;
  1427.               gad1 = (struct MyGadget *)(gad1->GNode.ln_Succ)){
  1428.             if (gad == gad1->OwnCycle) {
  1429.                 for (; !(i > gad1->Activey); i++) {
  1430.                     val = (struct MyValue *)gad->VList.lh_Head;
  1431.                     for (j = 0; (j < i); j++) {
  1432.                         val = (struct MyValue *)val->VNode.ln_Succ;
  1433.                     }
  1434.                     FPrintf(gh->fp,"\t\"%s\":\"%s\"\n",val->VNode.ln_Name,val->Prefix);
  1435.                 }
  1436.                 PrintGadget(gh,gad1);
  1437.             }
  1438.         }
  1439.         for (; (i < gad->Numbery); i++) {
  1440.             val = (struct MyValue *)gad->VList.lh_Head;
  1441.             for (j = 0; (j < i); j++) {
  1442.                 val = (struct MyValue *)val->VNode.ln_Succ;
  1443.             }
  1444.             FPrintf(gh->fp,"\t\"%s\":\"%s\"\n",val->VNode.ln_Name,val->Prefix);
  1445.         }
  1446.         FPrintf(gh->fp,"\t%s:\"%ld\"\n","ENDCYCLE",gad->Defaulty);
  1447.         break;
  1448.     case GAD_CHECK:
  1449.         if (gad->NPrefix) {
  1450.             FPrintf(gh->fp,"%s \"%s\":\"%s\":\"%s\":%s",type,gad->Title,gad->Prefix,
  1451.                                                                     gad->NPrefix,gad->Defaultc?"Y":"N");
  1452.         }
  1453.         else {
  1454.             FPrintf(gh->fp,"%s \"%s\":\"%s\":%s",type,gad->Title,gad->Prefix,
  1455.                                                                     gad->Defaultc?"Y":"N");
  1456.         }
  1457.         PrintHelp(gh,gad);
  1458.         FPutC(gh->fp,'\n');
  1459.         break;
  1460.     case GAD_SLIDER:
  1461.         FPrintf(gh->fp,"%s \"%s\":\"%s\":\"%ld\":\"%ld\":\"%ld\"",type,gad->Title,gad->Prefix,
  1462.                                                                             gad->Minn,gad->Maxn,gad->Defaultn);
  1463.         PrintHelp(gh,gad);
  1464.         FPutC(gh->fp,'\n');
  1465.         break;
  1466.     case GAD_MODE:
  1467.     case GAD_FONT:
  1468.         FPrintf(gh->fp,"%s%ld \"%s\":\"%s\":\"%s\"",type,gad->ModeType,gad->Title,gad->Prefix,
  1469.                                                                             gad->Defaults);
  1470.         PrintHelp(gh,gad);
  1471.         FPutC(gh->fp,'\n');
  1472.         break;
  1473.     case GAD_OMODE:
  1474.     case GAD_OFONT:
  1475.         FPrintf(gh->fp,"%s%ld \"%s\":\"%s\":\"%s\":%s",type,gad->ModeType,gad->Title,gad->Prefix,
  1476.                                                                             gad->Defaults,gad->Defaultc?"Y":"N");
  1477.         PrintHelp(gh,gad);
  1478.         FPutC(gh->fp,'\n');
  1479.         break;
  1480.     case GAD_LIST:
  1481.         FPrintf(gh->fp,"%s \"%s\"",type,gad->Title);
  1482.         PrintHelp(gh,gad);
  1483.         FPutC(gh->fp,'\n');
  1484.         val = (struct MyValue *)gad->VList.lh_Head;
  1485.         for (i=0; (i < gad->Numbery); i++) {
  1486.             if (gad->OwnCycle) {
  1487.                 FPutC(gh->fp,'\t');
  1488.             }
  1489.             FPrintf(gh->fp,"\t\t\"%s\":\"%s\"\n",val->VNode.ln_Name,val->Prefix);
  1490.             val = (struct MyValue *)val->VNode.ln_Succ;
  1491.         }
  1492.         if (gad->OwnCycle) {
  1493.             FPutC(gh->fp,'\t');
  1494.         }
  1495.         FPrintf(gh->fp,"\t%s:\"%ld\":\"%ld\"\n","ENDLIST",gad->Defaulty,gad->Lines);
  1496.         break;
  1497.     case GAD_MLIST:
  1498.         FPrintf(gh->fp,"%s \"%s\"",type,gad->Title);
  1499.         PrintHelp(gh,gad);
  1500.         FPutC(gh->fp,'\n');
  1501.         val = (struct MyValue *)gad->VList.lh_Head;
  1502.         for (i=0; (i < gad->Numbery); i++) {
  1503.             if (gad->OwnCycle) {
  1504.                 FPutC(gh->fp,'\t');
  1505.             }
  1506.             if (val->NPrefix) {
  1507.                 FPrintf(gh->fp,"\t\t\"%s\":\"%s\":\"%s\"\n",val->VNode.ln_Name,val->Prefix,val->NPrefix);
  1508.             }
  1509.             else {
  1510.                 FPrintf(gh->fp,"\t\t\"%s\":\"%s\"\n",val->VNode.ln_Name,val->Prefix);
  1511.             }
  1512.             val = (struct MyValue *)val->VNode.ln_Succ;
  1513.         }
  1514.         if (gad->OwnCycle) {
  1515.             FPutC(gh->fp,'\t');
  1516.         }
  1517.         FPrintf(gh->fp,"\t%s:\"%s\":\"%ld\"\n","ENDMLIST",gad->Defaults,gad->Lines);
  1518.         break;
  1519.     case GAD_BUTTONTEXT:
  1520.         {
  1521.             struct MyGadget* gad1;
  1522.             FPrintf(gh->fp,"\t%s:\"%s\"\n",type,gad->Title);
  1523.             for (gad1 = (struct MyGadget *)gad->GNode.ln_Succ;
  1524.                   gad1->GNode.ln_Succ && (GAD_BUTTON == gad1->Type);
  1525.                   gad1 = (struct MyGadget *)gad1->GNode.ln_Succ) {
  1526.                 if (gad->OwnCycle) {
  1527.                     FPutC(gh->fp,'\t');
  1528.                 }
  1529.                 FPrintf(gh->fp,"\t\t\"%s\":\"%ld\"",gad1->Title,gad1->ButtonNo);
  1530.                 PrintHelp(gh,gad1);
  1531.                 FPutC(gh->fp,'\n');
  1532.             }
  1533.             if (gad->OwnCycle) {
  1534.                 FPutC(gh->fp,'\t');
  1535.             }
  1536.             FPrintf(gh->fp,"\tENDBUTTON\n");
  1537.         }
  1538.         break;
  1539.     case GAD_BUTTON:
  1540.         break;
  1541.     default:
  1542.         FPuts(gh->fp,"??\n");
  1543.         break;
  1544.     }
  1545.     return TRUE;
  1546. }
  1547.  
  1548. /****** MPGui.library/WriteMPGui ********************************************
  1549. *
  1550. *   NAME   
  1551. *  WriteMPGui -- Writes information for an MPGui. (V4)
  1552. *
  1553. *   SYNOPSIS
  1554. *  result = WriteMPGui( fname, gh)
  1555. *  D0                         A0     A1
  1556. *
  1557. *  BOOL WriteMPGui( char *, struct MPGuiHandle *);
  1558. *
  1559. *   FUNCTION
  1560. *  Writes all the information in the file for an MPGuiHandle allocated by
  1561. *  AllocMPGuiHandle().
  1562. *
  1563. *   INPUTS
  1564. *  fname - name of file to describe the gui.
  1565. *  gh    - MPGuiHandle allocated by AllocMPGuiHandle().
  1566. *
  1567. *   RESULT
  1568. *  TRUE if file written OK
  1569. *  FALSE for error. Use MPGuiError() to get error.
  1570. *
  1571. *   EXAMPLE
  1572. *
  1573. *   NOTES
  1574. *  Ignores any tags supplied to AllocMPGuiHandleA().
  1575. *
  1576. *  This currently serves no purpose, but may be later used for a gui based
  1577. *  gui designer.
  1578. *
  1579. *   BUGS
  1580. *
  1581. * Currently does nothing!
  1582. * Does not handle TEXT/MTEXT
  1583. *
  1584. *   SEE ALSO
  1585. *  AllocMPGuiHandleA(),MPGuiError(),ReadMPGui().
  1586. *
  1587. *****************************************************************************
  1588. *
  1589. */
  1590. #endif
  1591. BOOL __saveds __asm
  1592. WriteMPGui(register __a0 char *fname,register __a1 struct MPGuiHandle *gh) {
  1593. #if 0
  1594.     int i;
  1595.     struct MyGadget *gad;
  1596.     if (!fname || !gh) {
  1597.         pError(gh,GetMessage(MSG_ERR_NOPW),NULL);
  1598.         return FALSE;
  1599.     }
  1600.     if (gh->fp = Open(fname,MODE_NEWFILE)) {
  1601.         for (i=0; i<6; i++) {
  1602.             if (gh->comment[i]) {
  1603.                 FPrintf(gh->fp,"%s\n",gh->comment[i]);
  1604.             }
  1605.         }
  1606.         FPutC(gh->fp,'\n');
  1607.         FPrintf(gh->fp,"\"%s\"%s",gh->Command,gh->HelpMessage);
  1608.         FPrintf(gh->fp,"\t\"%s\"\n",gh->Comment);
  1609.         FPrintf(gh->fp,"\t\"%s\"\n",gh->HelpNode);
  1610.         for (gad = (struct MyGadget *)gh->GList.lh_Head;
  1611.               gad->GNode.ln_Succ;
  1612.               gad = (struct MyGadget *)gad->GNode.ln_Succ) {
  1613.             if (!gad->OwnCycle) {
  1614.                 PrintGadget(gh,gad);
  1615.             }
  1616.         }
  1617.         Close(gh->fp);
  1618.     }
  1619.     else {
  1620.         pError(gh,GetMessage(MSG_ERR_OPENF),fname);
  1621.     }
  1622.     if (gh->FoundError) {
  1623.         return FALSE;
  1624.     }
  1625.     else {
  1626.         return TRUE;
  1627.     }
  1628. #else
  1629.     return TRUE;
  1630. #endif
  1631. }
  1632.  
  1633. /****** MPGui.library/RefreshMPGui ******************************************
  1634. *
  1635. *   NAME   
  1636. *  RefreshMPGui -- Refreshes an MPGui Window. (V5)
  1637. *
  1638. *   SYNOPSIS
  1639. *  RefreshMPGui(gh)
  1640. *               A0
  1641. *
  1642. *  void RefreshMPGui(struct MPGuiHandle *);
  1643. *
  1644. *   FUNCTION
  1645. *  Refreshes an MPGui Window.
  1646. *
  1647. *   INPUTS
  1648. *  gh    - MPGuiHandle allocated by AllocMPGuiHandle().
  1649. *
  1650. *   RESULT
  1651. *  None
  1652. *
  1653. *   EXAMPLE
  1654. *
  1655. *   NOTES
  1656. *  Use in a call back hook - e.g. if a menu item opens a file requester.
  1657. *
  1658. *   BUGS
  1659. *
  1660. *   SEE ALSO
  1661. *  AllocMPGuiHandleA(), SyncMPGuiRequest().
  1662. *
  1663. *****************************************************************************
  1664. *
  1665. */
  1666. void __saveds __asm
  1667. RefreshMPGui(register __a0 struct MPGuiHandle *gh) {
  1668.     if (gh) {
  1669.         if (gh->Window) {
  1670.             GT_BeginRefresh(gh->Window);
  1671.             GT_EndRefresh(gh->Window,TRUE);
  1672.         }
  1673.     }
  1674. }
  1675.  
  1676. /****** MPGui.library/MPGuiWindow *******************************************
  1677. *
  1678. *   NAME   
  1679. *  MPGuiWindow -- Returns the Window for an MPGui. (V5)
  1680. *
  1681. *   SYNOPSIS
  1682. *  Window = MPGuiWindow(gh)
  1683. *  D0                   A0
  1684. *
  1685. *  struct Window *MPGuiWindow(struct MPGuiHandle *);
  1686. *
  1687. *   FUNCTION
  1688. *  Returns the Window for an MPGui.
  1689. *
  1690. *   INPUTS
  1691. *  gh    - MPGuiHandle allocated by AllocMPGuiHandle().
  1692. *
  1693. *   RESULT
  1694. *  The Window for the GUI - if open.
  1695. *
  1696. *   EXAMPLE
  1697. *
  1698. *   NOTES
  1699. *  Use in a call back hook - e.g. if a menu item opens a file requester.
  1700. *
  1701. *   BUGS
  1702. *
  1703. *   SEE ALSO
  1704. *  AllocMPGuiHandleA(), SyncMPGuiRequest().
  1705. *
  1706. *****************************************************************************
  1707. *
  1708. */
  1709. struct Window * __saveds __asm
  1710. MPGuiWindow(register __a0 struct MPGuiHandle *gh) {
  1711.     if (gh) {
  1712.         return gh->Window;
  1713.     }
  1714.     return NULL;
  1715. }
  1716.  
  1717. int
  1718. sprintf(char *buffer,const char *ctl, ...) {
  1719.    va_list args;
  1720.  
  1721.    va_start(args, ctl);
  1722.  
  1723.    /*********************************************************/
  1724.    /* NOTE: The string below is actually CODE that copies a */
  1725.    /*       value from d0 to A3 and increments A3:          */
  1726.    /*                                                       */
  1727.    /*          move.b d0,(a3)+                              */
  1728.    /*          rts                                          */
  1729.    /*                                                       */
  1730.    /*       It is essentially the callback routine needed   */
  1731.    /*       by RawDoFmt.                                    */
  1732.    /*********************************************************/
  1733.  
  1734.    RawDoFmt((char *)ctl, args, (void (*))"\x16\xc0\x4e\x75", buffer);
  1735.  
  1736.    va_end(args);
  1737.  
  1738.    return 0;
  1739. }
  1740.  
  1741. /* clone of strdup using pooled memory */
  1742. char
  1743. *mystrdup(struct MPGuiHandle *gh,char *old) {
  1744.     char *ptr;
  1745.     if (!old) {
  1746.         return NULL;
  1747.     }
  1748.     if (ptr = AllocPooled(gh->MemPool,strlen(old)+1)) {
  1749.         strcpy(ptr,old);
  1750.     }
  1751.     return ptr;
  1752. }
  1753.  
  1754. /* Does all the input file processing for a command */
  1755. void
  1756. Command(struct MPGuiHandle *gh) {
  1757.     char *s,*s1;
  1758.     NewList(&(gh->GList));
  1759.     s = strchr(&(gh->buffer[1]),'"');
  1760.     if (s) {
  1761.         *s = 0;
  1762.         gh->Command = mystrdup(gh,&(gh->buffer[1]));
  1763.         gh->HelpMessage = mystrdup(gh,++s);
  1764.         while ((s = myfgets(gh)) && !strchr(gh->buffer,'"')) {
  1765.         }
  1766.         if (s) {
  1767.             s = strchr(gh->buffer,'"');
  1768.             s1 = strchr(s+1,'"');
  1769.             if (s1) {
  1770.                 *s1=0;
  1771.                 gh->Comment = mystrdup(gh,s+1);
  1772.                 if (!gh->HelpMessage) {
  1773.                     gh->HelpMessage = gh->Comment;
  1774.                 }
  1775.                 gh->TitleLength = TextLength(&(gh->MyScreen->RastPort),gh->Comment,strlen(gh->Comment));
  1776.                 if (myfgets(gh)) {
  1777.                     s = strchr(gh->buffer,'"');
  1778.                     if (s) {
  1779.                         s1 = strchr(s+1,'"');
  1780.                         if (s1) {
  1781.                             *s1=0;
  1782.                             gh->HelpNode = mystrdup(gh,s+1);
  1783.                             while (myfgets(gh)) {
  1784.                                 ProcessGadget(gh);
  1785.                             }
  1786.                          }
  1787.                         else {
  1788.                             pError(gh,GetMessage(MSG_ERR_TEEQ),NULL);
  1789.                             while (myfgets(gh) && (gh->buffer[0] != '\n')) {
  1790.                             }
  1791.                         }
  1792.                     }
  1793.                     else {
  1794.                         pError(gh,GetMessage(MSG_ERR_TSSQ),NULL);
  1795.                         while (myfgets(gh) && (gh->buffer[0] != '\n')) {
  1796.                         }
  1797.                     }
  1798.                 }
  1799.                 else {
  1800.                     pError(gh,GetMessage(MSG_ERR_TEOF),NULL);
  1801.                 }
  1802.             }
  1803.             else {
  1804.                 pError(gh,GetMessage(MSG_ERR_COMMTQ),NULL);
  1805.             }
  1806.         }
  1807.         else {
  1808.             pError(gh,GetMessage(MSG_ERR_COMEOF),NULL);
  1809.         }
  1810.     }
  1811.     else {
  1812.         pError(gh,GetMessage(MSG_ERR_COMTQ),NULL);
  1813.     }
  1814. }
  1815.  
  1816. void
  1817. pError(struct MPGuiHandle *gh,const char *a,char *b) {
  1818.     if (!gh->OutOfMemory) {
  1819.         sprintf(gh->TempFileName,GetMessage(MSG_ERR_LINE),gh->linenumber);
  1820.         strncat(gh->error,gh->TempFileName,1024);
  1821.         sprintf(gh->TempFileName,a,b);
  1822.         strncat(gh->error,gh->TempFileName,1024);
  1823.         strncat(gh->error,"\n",1024);
  1824.     }
  1825.     ++gh->FoundError;
  1826. }
  1827.  
  1828. static char wbuffer[2048];
  1829.  
  1830. char
  1831. *myfgets(struct MPGuiHandle *gh) {
  1832.     char *s;
  1833.     int i;
  1834.     if ((gh->FoundError > 10) || (gh->OutOfMemory)) {
  1835.         return NULL;
  1836.     }
  1837.     ++gh->linenumber;
  1838.     while ((s = FGets(gh->fp,gh->buffer,256)) && ((gh->buffer[0] == '*') || (gh->buffer[0] == '\n'))) {
  1839.         if (gh->buffer[0] == '*') {
  1840.             if (!gh->comment[6]) {
  1841.                 for (i=0; i<6; i++) {
  1842.                     if (!gh->comment[i]) {
  1843.                         s[strlen(s)-1] = 0;
  1844.                         gh->comment[i] = mystrdup(gh,s);
  1845.                         i=6;
  1846.                     }
  1847.                 }
  1848.             }
  1849.         }
  1850.         ++gh->linenumber;
  1851.     }
  1852.     if (!s) {
  1853.         return NULL;
  1854.     }
  1855.     s[strlen(s)-1] = 0;
  1856.     // Convert \ formats, \" is converted to 1 and converted back later
  1857.     if (strstr(s,"\\")) {
  1858.         char *s1,*s2;
  1859.         s1 = s;
  1860.         s2 = wbuffer;
  1861.         while (*s1) {
  1862.             if ('\\' == *s1) {
  1863.                 ++s1;
  1864.                 switch (*s1) {
  1865.                 case '\\':
  1866.                     *s2++ = '\\';
  1867.                     ++s1;
  1868.                     break;
  1869.                 case '"':
  1870.                     *s2++ = '\001';
  1871.                     ++s1;
  1872.                     break;
  1873.                 case 't':
  1874.                     *s2++ = '\t';
  1875.                     ++s1;
  1876.                     break;
  1877.                 case 'n':
  1878.                     *s2++ = '\n';
  1879.                     ++s1;
  1880.                     break;
  1881.                 default:
  1882.                     *s2++ = *s1++;
  1883.                     break;
  1884.                 }
  1885.             }
  1886.             else {
  1887.                 *s2++ = *s1++;
  1888.             }
  1889.         }
  1890.         *s2 = 0;
  1891.         strcpy(gh->buffer,wbuffer);
  1892.         s = gh->buffer;
  1893.     }
  1894.     if (!gh->Params || !s) {
  1895.         return s;
  1896.     }
  1897.     else {
  1898.         char *s1,*s2,*s3;
  1899.         BOOL found = FALSE;
  1900.         BOOL flag;
  1901.         int i,j;
  1902.  
  1903.         s1 = s;
  1904.         s2 = wbuffer;
  1905.         while (*s1) {
  1906.             if (*s1 != '#') {
  1907.                 *s2++ = *s1++;
  1908.             }
  1909.             else {
  1910.                 found = TRUE;
  1911.                 s1++;
  1912.                 if (*s1 == '#') {
  1913.                     *s2++ = *s1++;
  1914.                 }
  1915.                 else {
  1916.                     if (isdigit(*s1)) {
  1917.                         i = atoi(s1);
  1918.                         flag = TRUE;
  1919.                         for (j = 0; j<(i+1); ++j) {
  1920.                             if (!gh->Params[j]) {
  1921.                                 flag = FALSE;
  1922.                                 j = i+1;
  1923.                             }
  1924.                         }
  1925.                         if (flag) {
  1926.                             s3 = gh->Params[i];
  1927.                         }
  1928.                         else {
  1929.                             s3 = "";
  1930.                         }
  1931.                         while (*s3) {
  1932.                             *s2++ = *s3++;
  1933.                         }
  1934.                         while (*s1 && (*s1 != '#')) {
  1935.                             s1++;
  1936.                         }
  1937.                         if (*s1) {
  1938.                             s1++;
  1939.                         }
  1940.                     }
  1941.                 }
  1942.             }
  1943.         }
  1944.         if (!found) {
  1945.             return s;
  1946.         }
  1947.         else {
  1948.             *s2 = 0;
  1949.             strcpy(gh->buffer,wbuffer);
  1950.             return gh->buffer;
  1951.         }
  1952.     }
  1953. }
  1954.  
  1955. #define ALPHA (char *)"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
  1956. #define NUMBER (char *)"0123456789"
  1957.  
  1958. void
  1959. ProcessGadget(struct MPGuiHandle *gh) {
  1960.     char *s;
  1961.     int temp=0,temp1=0;
  1962.  
  1963.     if (gh->CurrentGadget = (struct MyGadget *)AllocPooled(gh->MemPool,sizeof(struct MyGadget))) {
  1964.         NewList(&(gh->CurrentGadget->VList));
  1965.         AddTail(&(gh->GList),&(gh->CurrentGadget->GNode));
  1966.         if (gh->CurrentCycle) {
  1967.             gh->CurrentGadget->Activey = gh->CurrentCycleVal;
  1968.             gh->CurrentGadget->OwnCycle = gh->CurrentCycle;
  1969.         }
  1970.     }
  1971.     else {
  1972.         pError(gh,GetMessage(MSG_ERR_NOMEM),NULL);
  1973.         gh->OutOfMemory = 1;
  1974.         return;
  1975.     }
  1976.     s = SkipSpace(gh->buffer);
  1977.     if (s) {
  1978.         if (!strncmp(s,"FILE",strlen("FILE"))) {
  1979.             gh->CurrentGadget->Type = GAD_FILE;
  1980.         }
  1981.         else if (!strncmp(s,"LFILE",strlen("LFILE"))) {
  1982.             gh->CurrentGadget->Type = GAD_LFILE;
  1983.         }
  1984.         else if (!strncmp(s,"SFILE",strlen("SFILE"))) {
  1985.             gh->CurrentGadget->Type = GAD_SFILE;
  1986.         }
  1987.         else if (!strncmp(s,"OFILE",strlen("OFILE"))) {
  1988.             gh->CurrentGadget->Type = GAD_OFILE;
  1989.         }
  1990.         else if (!strncmp(s,"ONUMBER",strlen("ONUMBER"))) {
  1991.             gh->CurrentGadget->Type = GAD_ONUMBER;
  1992.         }
  1993.         else if (!strncmp(s,"NUMBER",strlen("NUMBER"))) {
  1994.             gh->CurrentGadget->Type = GAD_NUMBER;
  1995.         }
  1996.         else if (!strncmp(s,"CYCLE",strlen("CYCLE"))) {
  1997.             gh->CurrentGadget->Type = GAD_CYCLE;
  1998.         }
  1999.         else if (!strncmp(s,"STRING",strlen("STRING"))) {
  2000.             gh->CurrentGadget->Type = GAD_STRING;
  2001.         }
  2002.         else if (!strncmp(s,"TEXT",strlen("TEXT"))) {
  2003.             gh->CurrentGadget->Type = GAD_TEXT;
  2004.         }
  2005.         else if (!strncmp(s,"MTEXT",strlen("MTEXT"))) {
  2006.             gh->CurrentGadget->Type = GAD_MTEXT;
  2007.         }
  2008.         else if (!strncmp(s,"OSTRING",strlen("OSTRING"))) {
  2009.             gh->CurrentGadget->Type = GAD_OSTRING;
  2010.         }
  2011.         else if (!strncmp(s,"CHECK",strlen("CHECK"))) {
  2012.             gh->CurrentGadget->Type = GAD_CHECK;
  2013.         }
  2014.         else if (!strncmp(s,"SLIDER",strlen("SLIDER"))) {
  2015.             gh->CurrentGadget->Type = GAD_SLIDER;
  2016.         }
  2017.         else if (!strncmp(s,"MODE",strlen("MODE"))) {
  2018.             gh->CurrentGadget->Type = GAD_MODE;
  2019.         }
  2020.         else if (!strncmp(s,"OMODE",strlen("OMODE"))) {
  2021.             gh->CurrentGadget->Type = GAD_OMODE;
  2022.         }
  2023.         else if (!strncmp(s,"FONT",strlen("FONT"))) {
  2024.             gh->CurrentGadget->Type = GAD_FONT;
  2025.         }
  2026.         else if (!strncmp(s,"OFONT",strlen("OFONT"))) {
  2027.             gh->CurrentGadget->Type = GAD_OFONT;
  2028.         }
  2029.         else if (!strncmp(s,"LIST",strlen("LIST"))) {
  2030.             gh->CurrentGadget->Type = GAD_LIST;
  2031.         }
  2032.         else if (!strncmp(s,"MLIST",strlen("MLIST"))) {
  2033.             gh->CurrentGadget->Type = GAD_MLIST;
  2034.         }
  2035.         else if (!strncmp(s,"BUTTON",strlen("BUTTON"))) {
  2036.             gh->CurrentGadget->Type = GAD_BUTTONTEXT;
  2037.         }
  2038.         else {
  2039.             pError(gh,GetMessage(MSG_ERR_UNG),s);
  2040.             while(myfgets(gh)) {
  2041.                 /* */
  2042.             }
  2043.             gh->CurrentGadget->Type = 0;
  2044.         }
  2045.         switch (gh->CurrentGadget->Type) {
  2046.         case GAD_FILE:
  2047.         case GAD_SFILE:
  2048.         case GAD_LFILE:
  2049.             GetTitle(TRUE,gh);
  2050.             GetParameter(gh);
  2051.             GetStringDefault(gh);
  2052.             GetHelp(gh);
  2053.             temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/3 + (GADGETWIDTH + INTERWIDTH);
  2054.             temp1 = (52*8/3) + (GADGETWIDTH + INTERWIDTH);
  2055.             break;
  2056.         case GAD_OFILE:
  2057.             GetTitle(TRUE,gh);
  2058.             GetParameter(gh);
  2059.             GetStringDefault(gh);
  2060.             GetCheckDefault(gh);
  2061.             GetHelp(gh);
  2062.             temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/3 + (GADGETWIDTH * 2 + INTERWIDTH * 2);
  2063.             temp1 = (52*8/3) + (GADGETWIDTH * 2 + INTERWIDTH * 2);
  2064.             break;
  2065.         case GAD_ONUMBER:
  2066.             GetTitle(TRUE,gh);
  2067.             GetParameter(gh);
  2068.             GetNumberDefault(gh);
  2069.             GetCheckDefault(gh);
  2070.             GetHelp(gh);
  2071.             temp = TextLength(&(gh->MyScreen->RastPort),NUMBER,strlen(NUMBER))*2/3 + (GADGETWIDTH + INTERWIDTH);
  2072.             temp1 = (10*8/3) + (GADGETWIDTH + INTERWIDTH);
  2073.             break;
  2074.         case GAD_NUMBER:
  2075.             GetTitle(TRUE,gh);
  2076.             GetParameter(gh);
  2077.             GetNumberDefault(gh);
  2078.             GetHelp(gh);
  2079.             temp = TextLength(&(gh->MyScreen->RastPort),NUMBER,strlen(NUMBER))*2/3;
  2080.             temp1 = (10*8/3);
  2081.             break;
  2082.         case GAD_CYCLE:
  2083.             if (gh->CurrentCycle) {
  2084.                 pError(gh,GetMessage(MSG_ERR_CYCLECYCLE),NULL);
  2085.             }
  2086.             else {
  2087.                 GetTitle(TRUE,gh);
  2088.                 GetHelp(gh);
  2089.                 ProcessCycle(gh);
  2090.             }
  2091.             temp = gh->rightsize;
  2092.             temp1 = gh->trightsize;
  2093.             break;
  2094.         case GAD_STRING:
  2095.             GetTitle(TRUE,gh);
  2096.             GetParameter(gh);
  2097.             GetStringDefault(gh);
  2098.             GetHelp(gh);
  2099.             temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/3;
  2100.             temp1 = (52*8/3);
  2101.             break;
  2102.         case GAD_TEXT:
  2103.             GetTitle(TRUE,gh);
  2104.             GetStringDefault(gh);
  2105.             GetCheckDefault(gh);
  2106.             GetHelp(gh);
  2107.             temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/3;
  2108.             temp1 = (52*8/3);
  2109.             break;
  2110.         case GAD_MTEXT:
  2111.             gh->CurrentPos = gh->buffer;
  2112.             GetStringDefault(gh);
  2113.             GetCheckDefault(gh);
  2114.             GetHelp(gh);
  2115.             temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/3;
  2116.             temp1 = (52*8/3);
  2117.             break;
  2118.         case GAD_OSTRING:
  2119.             GetTitle(TRUE,gh);
  2120.             GetParameter(gh);
  2121.             GetStringDefault(gh);
  2122.             GetCheckDefault(gh);
  2123.             GetHelp(gh);
  2124.             temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/3 + (GADGETWIDTH + INTERWIDTH);
  2125.             temp1 = (52*8/3) + (GADGETWIDTH + INTERWIDTH);
  2126.             break;
  2127.         case GAD_CHECK:
  2128.             GetTitle(TRUE,gh);
  2129.             GetParameter(gh);
  2130.             GetNParameter(gh);
  2131.             GetCheckDefault(gh);
  2132.             GetHelp(gh);
  2133.             temp = GADGETWIDTH;
  2134.             temp1 = GADGETWIDTH;
  2135.             break;
  2136.         case GAD_SLIDER:
  2137.             GetTitle(TRUE,gh);
  2138.             GetParameter(gh);
  2139.             GetNumberDefault(gh);
  2140.             gh->CurrentGadget->Minn = gh->CurrentGadget->Defaultn;
  2141.             GetNumberDefault(gh);
  2142.             gh->CurrentGadget->Maxn = gh->CurrentGadget->Defaultn;
  2143.             GetNumberDefault(gh);
  2144.             GetHelp(gh);
  2145.             if (gh->CurrentGadget->Defaultn < gh->CurrentGadget->Minn) {
  2146.                 gh->CurrentGadget->Defaultn = gh->CurrentGadget->Minn;
  2147.             }
  2148.             if (gh->CurrentGadget->Defaultn > gh->CurrentGadget->Maxn) {
  2149.                 gh->CurrentGadget->Defaultn = gh->CurrentGadget->Maxn;
  2150.             }
  2151.             gh->CurrentGadget->Currentn = gh->CurrentGadget->Defaultn;
  2152.             gh->CurrentGadget->logMaxn = 1;
  2153.             if (gh->CurrentGadget->Maxn > 9) {
  2154.                 gh->CurrentGadget->logMaxn = 2;
  2155.                 if (gh->CurrentGadget->Maxn > 99) {
  2156.                     gh->CurrentGadget->logMaxn = 3;
  2157.                     if (gh->CurrentGadget->Maxn > 999) {
  2158.                         gh->CurrentGadget->logMaxn = 4;
  2159.                         if (gh->CurrentGadget->Maxn > 9999) {
  2160.                             gh->CurrentGadget->logMaxn = 5;
  2161.                             if (gh->CurrentGadget->Maxn > 99999) {
  2162.                                 gh->CurrentGadget->logMaxn = 6;
  2163.                             }
  2164.                         }
  2165.                     }
  2166.                 }
  2167.             }
  2168.             temp = (GADGETWIDTH * 2 + INTERWIDTH) + TextLength(&(gh->MyScreen->RastPort),NUMBER,strlen(NUMBER))* gh->CurrentGadget->logMaxn/10;
  2169.             temp1 = (GADGETWIDTH*2 + INTERWIDTH)+gh->CurrentGadget->logMaxn*8;
  2170.             break;
  2171.         case GAD_MODE:
  2172.             s += 4;
  2173.             if ((*s > '0') && (*s < '5')) {
  2174.                 gh->CurrentGadget->ModeType = *s - '0';
  2175.                 GetTitle(TRUE,gh);
  2176.                 GetParameter(gh);
  2177.                 GetStringDefault(gh);
  2178.                 GetHelp(gh);
  2179.                 temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/2 + (GADGETWIDTH + INTERWIDTH);
  2180.                 temp1 = (52*8/2) + (GADGETWIDTH + INTERWIDTH);
  2181.             }
  2182.             else {
  2183.                 pError(gh,GetMessage(MSG_ERR_MODEN),NULL);
  2184.                 temp = gh->rightsize;
  2185.                 temp1 = gh->trightsize;
  2186.             }
  2187.             break;
  2188.         case GAD_OMODE:
  2189.             s += 5;
  2190.             if ((*s > '0') && (*s < '5')) {
  2191.                 gh->CurrentGadget->ModeType = *s - '0';
  2192.                 GetTitle(TRUE,gh);
  2193.                 GetParameter(gh);
  2194.                 GetStringDefault(gh);
  2195.                 GetCheckDefault(gh);
  2196.                 GetHelp(gh);
  2197.                 temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/2 + (GADGETWIDTH * 2 + INTERWIDTH * 2);
  2198.                 temp1 = (52*8/2) + (GADGETWIDTH * 2 + INTERWIDTH * 2);
  2199.             }
  2200.             else {
  2201.                 temp = gh->rightsize;
  2202.                 temp1 = gh->trightsize;
  2203.                 pError(gh,GetMessage(MSG_ERR_OMODEN),NULL);
  2204.             }
  2205.             break;
  2206.         case GAD_FONT:
  2207.             s += 4;
  2208.             if ((*s > '0') && (*s < '3')) {
  2209.                 gh->CurrentGadget->ModeType = *s - '0';
  2210.                 GetTitle(TRUE,gh);
  2211.                 GetParameter(gh);
  2212.                 GetStringDefault(gh);
  2213.                 GetHelp(gh);
  2214.                 temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/2 + (GADGETWIDTH + INTERWIDTH);
  2215.                 temp1 = (52*8/2) + (GADGETWIDTH + INTERWIDTH);
  2216.             }
  2217.             else {
  2218.                 temp = gh->rightsize;
  2219.                 temp1 = gh->trightsize;
  2220.                 pError(gh,GetMessage(MSG_ERR_FONTN),NULL);
  2221.             }
  2222.             break;
  2223.         case GAD_OFONT:
  2224.             s += 5;
  2225.             if ((*s > '0') && (*s < '3')) {
  2226.                 gh->CurrentGadget->ModeType = *s - '0';
  2227.                 GetTitle(TRUE,gh);
  2228.                 GetParameter(gh);
  2229.                 GetStringDefault(gh);
  2230.                 GetCheckDefault(gh);
  2231.                 GetHelp(gh);
  2232.                 temp = TextLength(&(gh->MyScreen->RastPort),ALPHA,strlen(ALPHA))/2 + (GADGETWIDTH * 2 + INTERWIDTH * 2);
  2233.                 temp1 = (52*8/2) + (GADGETWIDTH * 2 + INTERWIDTH * 2);
  2234.             }
  2235.             else {
  2236.                 pError(gh,GetMessage(MSG_ERR_OFONTN),NULL);
  2237.                 temp = gh->rightsize;
  2238.                 temp1 = gh->trightsize;
  2239.             }
  2240.             break;
  2241.         case GAD_LIST:
  2242.             GetTitle(TRUE,gh);
  2243.             GetHelp(gh);
  2244.             ProcessList(gh);
  2245.             gh->numlines += gh->CurrentGadget->Lines-1;
  2246.             gh->extralist += gh->CurrentGadget->Lines-1;
  2247.             temp = gh->rightsize;
  2248.             temp1 = gh->trightsize;
  2249.             break;
  2250.         case GAD_MLIST:
  2251.             GetTitle(TRUE,gh);
  2252.             GetHelp(gh);
  2253.             ProcessMList(gh);
  2254.             gh->numlines += gh->CurrentGadget->Lines-1;
  2255.             gh->extralist += gh->CurrentGadget->Lines-1;
  2256.             temp = gh->rightsize;
  2257.             temp1 = gh->trightsize;
  2258.             break;
  2259.         case GAD_BUTTONTEXT:
  2260.             GetTitle(FALSE,gh);
  2261.             {
  2262.                 int temp2;
  2263.                 temp2 = TextLength(&(gh->MyScreen->RastPort),gh->CurrentGadget->Title,strlen(gh->CurrentGadget->Title)) + INTERWIDTH;
  2264.                 if (temp2 > gh->leftsize) {
  2265.                     gh->leftsize = temp2;
  2266.                 }
  2267.                 temp2 = strlen(gh->CurrentGadget->Title) * 8 + INTERWIDTH;
  2268.                 if (temp2 > gh->tleftsize) {
  2269.                     gh->tleftsize = temp2;
  2270.                 }
  2271.             }
  2272.             ProcessButton(gh);
  2273.             temp = gh->rightsize;
  2274.             temp1 = gh->trightsize;
  2275.             break;
  2276.         default:
  2277.             break;
  2278.         }
  2279.         if (temp > gh->rightsize) {
  2280.             gh->rightsize = temp;
  2281.         }
  2282.         if (temp1 > gh->trightsize) {
  2283.             gh->trightsize = temp1;
  2284.         }
  2285.         ++gh->numlines;
  2286.     }
  2287.     else {
  2288.         pError(gh,GetMessage(MSG_ERR_UNSPC),NULL);
  2289.     }
  2290.     gh->CurrentGadget = NULL;
  2291. }
  2292.  
  2293. void
  2294. ProcessButton(struct MPGuiHandle *gh) {
  2295.     short endfound = 0;
  2296.     short first = 1;
  2297.     BOOL Left;
  2298.     char *s;
  2299.     int width = 0;
  2300.     int twidth = 0;
  2301.     struct MyGadget *Button;
  2302.  
  2303.     Button = gh->CurrentGadget;
  2304.     if (*gh->CurrentGadget->Title) {
  2305.         Left = TRUE;
  2306.     }
  2307.     else {
  2308.         Left = FALSE;
  2309.     }
  2310.     while (!endfound && myfgets(gh)) {
  2311.         s = SkipSpace(gh->buffer);
  2312.         if (s) {
  2313.             if ('"' == *s) {
  2314.                 first = 0;
  2315.                 if (gh->CurrentGadget = (struct MyGadget *)AllocPooled(gh->MemPool,sizeof(struct MyGadget))) {
  2316.                     NewList(&(gh->CurrentGadget->VList));
  2317.                     AddTail(&(gh->GList),&(gh->CurrentGadget->GNode));
  2318.                     if (gh->CurrentCycle) {
  2319.                         gh->CurrentGadget->Activey = gh->CurrentCycleVal;
  2320.                         gh->CurrentGadget->OwnCycle = gh->CurrentCycle;
  2321.                     }
  2322.                     gh->CurrentGadget->Type = GAD_BUTTON;
  2323.                     gh->CurrentGadget->OwnButton = Button;
  2324.                     ++Button->ButtonCount;
  2325.                     GetTitle(FALSE,gh);
  2326.                     GetNumberDefault(gh);
  2327.                     gh->CurrentGadget->ButtonNo = gh->CurrentGadget->Defaultn;
  2328.                     GetHelp(gh);
  2329.                     width += TextLength(&(gh->MyScreen->RastPort),gh->CurrentGadget->Title,strlen(gh->CurrentGadget->Title)) + INTERWIDTH;
  2330.                     twidth += 8*(strlen(gh->CurrentGadget->Title) + INTERWIDTH);
  2331.                 }
  2332.                 else {
  2333.                     pError(gh,GetMessage(MSG_ERR_NOMEM),NULL);
  2334.                     gh->OutOfMemory = 1;
  2335.                     return;
  2336.                 }
  2337.             }
  2338.             else {
  2339.                 if (!first) {
  2340.                     if (!strncmp(s,"ENDBUTTON",strlen("ENDBUTTON"))) {
  2341.                         width += INTERWIDTH * (Button->ButtonCount - 1);
  2342.                         twidth += INTERWIDTH * (Button->ButtonCount - 1);
  2343.                         if (Left) {
  2344.                             if (width > gh->rightsize) {
  2345.                                 gh->rightsize = width;
  2346.                             }
  2347.                             if (twidth > gh->trightsize) {
  2348.                                 gh->trightsize = twidth;
  2349.                             }
  2350.                         }
  2351.                         else {
  2352.                             if (width > gh->allsize) {
  2353.                                 gh->allsize = width;
  2354.                             }
  2355.                             if (twidth > gh->tallsize) {
  2356.                                 gh->tallsize = twidth;
  2357.                             }
  2358.                         }
  2359.                         endfound = 1;
  2360.                     }
  2361.                     else {
  2362.                         pError(gh,GetMessage(MSG_ERR_UNBUT),NULL);
  2363.                         return;
  2364.                     }
  2365.                 }
  2366.                 else {
  2367.                     pError(gh,GetMessage(MSG_ERR_FIRSTBUT),NULL);
  2368.                     while (myfgets(gh)) {
  2369.                         /* */
  2370.                     }
  2371.                 }
  2372.             }
  2373.         }
  2374.         else {
  2375.             pError(gh,GetMessage(MSG_ERR_ENDBSPC),NULL);
  2376.             return;
  2377.         }
  2378.     }
  2379.     if (!endfound) {
  2380.         pError(gh,GetMessage(MSG_ERR_ENDBEOF),NULL);
  2381.     }
  2382. }
  2383.  
  2384. void
  2385. ProcessCycle(struct MPGuiHandle *gh) {
  2386.     char *s;
  2387.     short endfound = 0;
  2388.     short first = 1;
  2389.     short StringCount = 0;
  2390.     struct MyValue *MyValue;
  2391.  
  2392.     gh->CurrentCycle = gh->CurrentGadget;
  2393.     gh->CurrentCycleVal = -1;
  2394.     while (!endfound && myfgets(gh)) {
  2395.         s = SkipSpace(gh->buffer);
  2396.         if (s) {
  2397.             if (*s == '"') {
  2398.                 first = 0;
  2399.                 if (gh->CurrentValue = (struct MyValue *)AllocPooled(gh->MemPool,sizeof(struct MyValue))) {
  2400.                     AddTail(&gh->CurrentCycle->VList,&gh->CurrentValue->VNode);
  2401.                     GetCycleTitle(gh);
  2402.                     GetCycleParameter(gh);
  2403.                     gh->CurrentValue = NULL;
  2404.                     ++StringCount;
  2405.                     ++gh->CurrentCycleVal;
  2406.                 }
  2407.                 else {
  2408.                     pError(gh,GetMessage(MSG_ERR_NOMEM),NULL);
  2409.                     gh->OutOfMemory = 1;
  2410.                     return;
  2411.                 }
  2412.             }
  2413.             else {
  2414.                 if (!first) {
  2415.                     if (!strncmp(s,"ENDCYCLE",strlen("ENDCYCLE"))) {
  2416.                         GetDefCycle(gh);
  2417.                         endfound = 1;
  2418.                     }
  2419.                     else {
  2420.                         ProcessGadget(gh);
  2421.                     }
  2422.                 }
  2423.                 else {
  2424.                     pError(gh,GetMessage(MSG_ERR_FIRSTCYC),NULL);
  2425.                     while (myfgets(gh)) {
  2426.                         /* */
  2427.                     }
  2428.                 }
  2429.             }
  2430.         }
  2431.         else {
  2432.             pError(gh,GetMessage(MSG_ERR_ENDCSPC),NULL);
  2433.             return;
  2434.         }
  2435.     }
  2436.     if (!endfound) {
  2437.         pError(gh,GetMessage(MSG_ERR_ENDCEOF),NULL);
  2438.     }
  2439.     if (gh->ptr = gh->CurrentCycle->VStrings = (STRPTR *)AllocPooled(gh->MemPool,sizeof(STRPTR)*(StringCount+1))) {
  2440.         for (MyValue = (struct MyValue *)gh->CurrentCycle->VList.lh_Head;
  2441.                 MyValue->VNode.ln_Succ;
  2442.                 MyValue = (struct MyValue *)MyValue->VNode.ln_Succ) {
  2443.             *(gh->ptr) = MyValue->VNode.ln_Name;
  2444.             (gh->ptr)++;
  2445.         }
  2446.         gh->CurrentCycle->Numbery = StringCount;
  2447.     }
  2448.     else {
  2449.         pError(gh,GetMessage(MSG_ERR_NOMEM),NULL);
  2450.         gh->OutOfMemory = 1;
  2451.         return;
  2452.     }
  2453.     gh->CurrentCycle = NULL;
  2454. }
  2455.  
  2456. void
  2457. ProcessList(struct MPGuiHandle *gh) {
  2458.     char *s;
  2459.     short endfound = 0;
  2460.     short first = 1;
  2461.     short StringCount = 0;
  2462.  
  2463.     while (!endfound && myfgets(gh)) {
  2464.         s = SkipSpace(gh->buffer);
  2465.         if (s) {
  2466.             if (*s == '"') {
  2467.                 first = 0;
  2468.                 if (gh->CurrentValue = (struct MyValue *)AllocPooled(gh->MemPool,sizeof(struct MyValue))) {
  2469.                     AddTail(&gh->CurrentGadget->VList,&gh->CurrentValue->VNode);
  2470.                     GetListTitle(gh);
  2471.                     GetListParameter(gh);
  2472.                     gh->CurrentValue = NULL;
  2473.                     ++StringCount;
  2474.                 }
  2475.                 else {
  2476.                     pError(gh,GetMessage(MSG_ERR_NOMEM),NULL);
  2477.                     gh->OutOfMemory = 1;
  2478.                     return;
  2479.                 }
  2480.             }
  2481.             else {
  2482.                 if (!first) {
  2483.                     if (!strncmp(s,"ENDLIST",strlen("ENDLIST"))) {
  2484.                         GetDefList(gh);
  2485.                         GetDefLines(gh);
  2486.                         endfound = 1;
  2487.                     }
  2488.                 }
  2489.                 else {
  2490.                     pError(gh,GetMessage(MSG_ERR_FIRSTLIST),NULL);
  2491.                     while (myfgets(gh)) {
  2492.                         /* */
  2493.                     }
  2494.                 }
  2495.             }
  2496.         }
  2497.         else {
  2498.             pError(gh,GetMessage(MSG_ERR_ENDLSPC),NULL);
  2499.             return;
  2500.         }
  2501.     }
  2502.     if (!endfound) {
  2503.         pError(gh,GetMessage(MSG_ERR_ENDLEOF),NULL);
  2504.     }
  2505.     gh->CurrentGadget->Numbery = StringCount;
  2506. }
  2507.  
  2508. void
  2509. ProcessMList(struct MPGuiHandle *gh) {
  2510.     char *s;
  2511.     short endfound = 0;
  2512.     short first = 1;
  2513.     short StringCount = 0;
  2514.  
  2515.     while (!endfound && myfgets(gh)) {
  2516.         s = SkipSpace(gh->buffer);
  2517.         if (s) {
  2518.             if (*s == '"') {
  2519.                 first = 0;
  2520.                 if (gh->CurrentValue = (struct MyValue *)AllocPooled(gh->MemPool,sizeof(struct MyValue))) {
  2521.                     AddTail(&gh->CurrentGadget->VList,&gh->CurrentValue->VNode);
  2522.                     GetListTitle(gh);
  2523.                     GetListParameter(gh);
  2524.                     GetListNParameter(gh);
  2525.                     gh->CurrentValue = NULL;
  2526.                     ++StringCount;
  2527.                 }
  2528.                 else {
  2529.                     pError(gh,GetMessage(MSG_ERR_NOMEM),NULL);
  2530.                     gh->OutOfMemory = 1;
  2531.                     return;
  2532.                 }
  2533.             }
  2534.             else {
  2535.                 if (!first) {
  2536.                     if (!strncmp(s,"ENDMLIST",strlen("ENDMLIST"))) {
  2537.                         GetDefMList(gh);
  2538.                         GetDefLines(gh);
  2539.                         endfound = 1;
  2540.                     }
  2541.                 }
  2542.                 else {
  2543.                     pError(gh,GetMessage(MSG_ERR_FIRSTLIST),NULL);
  2544.                     while (myfgets(gh)) {
  2545.                         /* */
  2546.                     }
  2547.                 }
  2548.             }
  2549.         }
  2550.         else {
  2551.             pError(gh,GetMessage(MSG_ERR_ENDLSPC),NULL);
  2552.             return;
  2553.         }
  2554.     }
  2555.     if (!endfound) {
  2556.         pError(gh,GetMessage(MSG_ERR_ENDLEOF),NULL);
  2557.     }
  2558.     gh->CurrentGadget->Numbery = StringCount;
  2559. }
  2560.  
  2561. void
  2562. GetTitle(BOOL SetLeft,struct MPGuiHandle *gh) {
  2563.     char *s;
  2564.     int temp;
  2565.  
  2566.     gh->CurrentPos = strchr(gh->buffer,'"');
  2567.     if (gh->CurrentPos) {
  2568.         s = gh->CurrentPos + 1;
  2569.         gh->CurrentPos = strchr(s,'"');
  2570.         if (gh->CurrentPos) {
  2571.             *gh->CurrentPos = 0;
  2572.             gh->CurrentGadget->Title = mystrdup(gh,s);
  2573.             if (SetLeft) {
  2574.                 temp = TextLength(&(gh->MyScreen->RastPort),s,strlen(s));
  2575.                 if (temp > gh->leftsize) {
  2576.                     gh->leftsize = temp;
  2577.                 }
  2578.                 temp = strlen(s) * 8;
  2579.                 if (temp > gh->tleftsize) {
  2580.                     gh->tleftsize = temp;
  2581.                 }
  2582.             }
  2583.             s = strchr(gh->CurrentGadget->Title,'_');
  2584.             if (s) {
  2585.                 char c;
  2586.                 ++s;
  2587.                 c = gh->CurrentGadget->Char = toupper(*s);
  2588.                 if (c == OKCHAR) {
  2589.                     gh->NoOk = TRUE;
  2590.                 }
  2591.                 if (c == USECHAR) {
  2592.                     gh->NoUse = TRUE;
  2593.                 }
  2594.                 if (c == SAVECHAR) {
  2595.                     gh->NoSave = TRUE;
  2596.                 }
  2597.                 if (c == CANCELCHAR) {
  2598.                     gh->NoCancel = TRUE;
  2599.                 }
  2600.             }
  2601.             ++(gh->CurrentPos);
  2602.         }
  2603.         else {
  2604.             pError(gh,GetMessage(MSG_ERR_TEQ),NULL);
  2605.         }
  2606.     }
  2607.     else {
  2608.         pError(gh,GetMessage(MSG_ERR_TSQ),NULL);
  2609.     }
  2610. }
  2611.  
  2612. void
  2613. GetParameter(struct MPGuiHandle *gh) {
  2614.     char *s;
  2615.     if (gh->CurrentPos) {
  2616.         gh->CurrentPos = strchr(gh->CurrentPos,'"');
  2617.         if (gh->CurrentPos) {
  2618.             s = gh->CurrentPos + 1;
  2619.             gh->CurrentPos = strchr(s,'"');
  2620.             if (gh->CurrentPos) {
  2621.                 *(gh->CurrentPos) = 0;
  2622.                 gh->CurrentGadget->Prefix = mystrdup(gh,s);
  2623.                 ++(gh->CurrentPos);
  2624.             }
  2625.             else {
  2626.                 pError(gh,GetMessage(MSG_ERR_PEQ),NULL);
  2627.             }
  2628.         }
  2629.         else {
  2630.             pError(gh,GetMessage(MSG_ERR_PSQ),NULL);
  2631.         }
  2632.     }
  2633. }
  2634.  
  2635. void
  2636. GetNParameter(struct MPGuiHandle *gh) {
  2637.     char *s;
  2638.     if (gh->CurrentPos) {
  2639.         s = strchr(gh->CurrentPos,'"');
  2640.         if (s) {
  2641.             gh->CurrentPos = s;
  2642.             s = gh->CurrentPos + 1;
  2643.             gh->CurrentPos = strchr(s,'"');
  2644.             if (gh->CurrentPos) {
  2645.                 *(gh->CurrentPos) = 0;
  2646.                 gh->CurrentGadget->NPrefix = mystrdup(gh,s);
  2647.                 ++(gh->CurrentPos);
  2648.             }
  2649.             else {
  2650.                 pError(gh,GetMessage(MSG_ERR_NPEQ),NULL);
  2651.             }
  2652.         }
  2653.     }
  2654. }
  2655.  
  2656. void
  2657. GetStringDefault(struct MPGuiHandle *gh) {
  2658.     char *s;
  2659.     if (gh->CurrentPos) {
  2660.         gh->CurrentPos = strchr(gh->CurrentPos,'"');
  2661.         if (gh->CurrentPos) {
  2662.             s = gh->CurrentPos + 1;
  2663.             gh->CurrentPos = strchr(s,'"');
  2664.             if (gh->CurrentPos) {
  2665.                 *(gh->CurrentPos) = 0;
  2666.                 gh->CurrentGadget->Defaults = mystrdup(gh,s);
  2667.                 ++(gh->CurrentPos);
  2668.             }
  2669.             else {
  2670.                 pError(gh,GetMessage(MSG_ERR_DEFEQ),NULL);
  2671.             }
  2672.         }
  2673.         else {
  2674.             gh->CurrentGadget->Defaults = (char *)"";
  2675.         }
  2676.     }
  2677.     else {
  2678.         gh->CurrentGadget->Defaults = (char *)"";
  2679.     }
  2680. }
  2681.  
  2682. void
  2683. GetNumberDefault(struct MPGuiHandle *gh) {
  2684.     char *s;
  2685.     long number;
  2686.     if (gh->CurrentPos) {
  2687.         gh->CurrentPos = strchr(gh->CurrentPos,'"');
  2688.         if (gh->CurrentPos) {
  2689.             s = gh->CurrentPos + 1;
  2690.             gh->CurrentPos = strchr(s,'"');
  2691.             if (gh->CurrentPos) {
  2692.                 *(gh->CurrentPos) = 0;
  2693.                 number = strtol(s,&(gh->CurrentPos),10);
  2694.                 gh->CurrentGadget->Defaultn = number;
  2695.                 ++(gh->CurrentPos);
  2696.             }
  2697.             else {
  2698.                 pError(gh,GetMessage(MSG_ERR_DEFEQ),NULL);
  2699.             }
  2700.         }
  2701.         else {
  2702.             number = 0;
  2703.             gh->CurrentGadget->Defaultn = number;
  2704.         }
  2705.     }
  2706.     else {
  2707.         number = 0;
  2708.         gh->CurrentGadget->Defaultn = number;
  2709.     }
  2710. }
  2711.  
  2712. void
  2713. GetCheckDefault(struct MPGuiHandle *gh) {
  2714.     char *s;
  2715.     short Check;
  2716.     if (gh->CurrentPos) {
  2717.         s = strpbrk(gh->CurrentPos,"YN");
  2718.         if (s && *s) {
  2719.             if (*s == 'Y') {
  2720.                 Check = 1;
  2721.                 gh->CurrentGadget->Defaultc = Check;
  2722.             }
  2723.             else {
  2724.                 Check = 0;
  2725.                 gh->CurrentGadget->Defaultc = Check;
  2726.             }
  2727.         }
  2728.         else {
  2729.             Check = 0;
  2730.             gh->CurrentGadget->Defaultc = Check;
  2731.         }
  2732.     }
  2733.     else {
  2734.         Check = 0;
  2735.         gh->CurrentGadget->Defaultc = Check;
  2736.     }
  2737.     gh->CurrentGadget->Currentc = gh->CurrentGadget->Defaultc;
  2738. }
  2739.  
  2740. void
  2741. GetDefCycle(struct MPGuiHandle *gh) {
  2742.     char *s;
  2743.     long number=0;
  2744.     long i;
  2745.     struct MyValue *MyValue;
  2746.  
  2747.     gh->CurrentPos = strchr(gh->buffer,'"');
  2748.     if (gh->CurrentPos) {
  2749.         s = gh->CurrentPos + 1;
  2750.         gh->CurrentPos = strchr(s,'"');
  2751.         if (gh->CurrentPos) {
  2752.             *(gh->CurrentPos) = 0;
  2753.             if (isdigit(*s)) {
  2754.                 number = strtol(s,&(gh->CurrentPos),10);
  2755.             }
  2756.             else {
  2757.                 i = 0;
  2758.                 for (MyValue = (struct MyValue *)(gh->CurrentCycle->VList.lh_Head);
  2759.                         MyValue->VNode.ln_Succ;
  2760.                         MyValue = (struct MyValue *)(MyValue->VNode.ln_Succ)){
  2761.                     if (!strcmp(s,MyValue->VNode.ln_Name)) {
  2762.                         number = i;
  2763.                     }
  2764.                     ++i;
  2765.                 }
  2766.             }
  2767.             gh->CurrentCycle->Defaulty = number;
  2768.             ++(gh->CurrentPos);
  2769.         }
  2770.         else {
  2771.             pError(gh,GetMessage(MSG_ERR_DEFEQ),NULL);
  2772.         }
  2773.     }
  2774.     else {
  2775.         number = 0;
  2776.         gh->CurrentCycle->Defaulty = number;
  2777.     }
  2778.     gh->CurrentCycle->Currenty = gh->CurrentCycle->Defaulty;
  2779. }
  2780.  
  2781. void
  2782. GetDefList(struct MPGuiHandle *gh) {
  2783.     char *s;
  2784.     long number=0;
  2785.     long i;
  2786.     struct MyValue *MyValue;
  2787.  
  2788.     gh->CurrentPos = strchr(gh->buffer,'"');
  2789.     if (gh->CurrentPos) {
  2790.         s = gh->CurrentPos + 1;
  2791.         gh->CurrentPos = strchr(s,'"');
  2792.         if (gh->CurrentPos) {
  2793.             *(gh->CurrentPos) = 0;
  2794.             if (isdigit(*s)) {
  2795.                 number = strtol(s,&(gh->CurrentPos),10);
  2796.             }
  2797.             else {
  2798.                 i = 0;
  2799.                 for (MyValue = (struct MyValue *)(gh->CurrentGadget->VList.lh_Head);
  2800.                         MyValue->VNode.ln_Succ;
  2801.                         MyValue = (struct MyValue *)(MyValue->VNode.ln_Succ)){
  2802.                     if (!strcmp(s,MyValue->VNode.ln_Name)) {
  2803.                         number = i;
  2804.                     }
  2805.                     ++i;
  2806.                 }
  2807.             }
  2808.             gh->CurrentGadget->Defaulty = number;
  2809.             ++(gh->CurrentPos);
  2810.         }
  2811.         else {
  2812.             pError(gh,GetMessage(MSG_ERR_DEFEQ),NULL);
  2813.         }
  2814.     }
  2815.     else {
  2816.         number = 0;
  2817.         gh->CurrentGadget->Defaulty = number;
  2818.     }
  2819.     gh->CurrentGadget->Currenty = gh->CurrentGadget->Defaulty;
  2820. }
  2821.  
  2822. void
  2823. GetDefMList(struct MPGuiHandle *gh) {
  2824.     char *s;
  2825.     struct MyValue *MyValue;
  2826.  
  2827.     gh->CurrentPos = strchr(gh->buffer,'"');
  2828.     if (gh->CurrentPos) {
  2829.         s = gh->CurrentPos + 1;
  2830.         gh->CurrentPos = strchr(s,'"');
  2831.         if (gh->CurrentPos) {
  2832.             *(gh->CurrentPos) = 0;
  2833.             gh->CurrentGadget->Defaults = mystrdup(gh,s);
  2834.             for (MyValue = (struct MyValue *)(gh->CurrentGadget->VList.lh_Head);
  2835.                     MyValue->VNode.ln_Succ;
  2836.                     MyValue = (struct MyValue *)(MyValue->VNode.ln_Succ)){
  2837.                 if (strstr(s,MyValue->VNode.ln_Name)) {
  2838.                     MyValue->Selected = TRUE;
  2839.                 }
  2840.             }
  2841.             ++(gh->CurrentPos);
  2842.         }
  2843.         else {
  2844.             pError(gh,GetMessage(MSG_ERR_DEFEQ),NULL);
  2845.         }
  2846.     }
  2847.     else {
  2848.         gh->CurrentGadget->Defaults = "";
  2849.     }
  2850. }
  2851.  
  2852. void
  2853. GetDefLines(struct MPGuiHandle *gh) {
  2854.     char *s;
  2855.  
  2856.     if (gh->CurrentPos) {
  2857.         gh->CurrentPos = strchr(gh->CurrentPos,'"');
  2858.         if (gh->CurrentPos) {
  2859.             s = gh->CurrentPos + 1;
  2860.             gh->CurrentPos = strchr(s,'"');
  2861.             if (gh->CurrentPos) {
  2862.                 *(gh->CurrentPos) = 0;
  2863.                 if (isdigit(*s)) {
  2864.                     gh->CurrentGadget->Lines = strtol(s,&(gh->CurrentPos),10);
  2865.                 }
  2866.                 else {
  2867.                     pError(gh,GetMessage(MSG_ERR_INVLL),NULL);
  2868.                 }
  2869.                 ++(gh->CurrentPos);
  2870.             }
  2871.             else {
  2872.                 pError(gh,GetMessage(MSG_ERR_LEQ),NULL);
  2873.             }
  2874.         }
  2875.         else {
  2876.             gh->CurrentGadget->Lines = 4;
  2877.         }
  2878.     }
  2879.     else {
  2880.         gh->CurrentGadget->Lines = 4;
  2881.     }
  2882. }
  2883.  
  2884. void
  2885. GetCycleTitle(struct MPGuiHandle *gh) {
  2886.     char *s;
  2887.     int temp;
  2888.     gh->CurrentPos = strchr(gh->buffer,'"');
  2889.     if (gh->CurrentPos) {
  2890.         s = gh->CurrentPos + 1;
  2891.         gh->CurrentPos = strchr(s,'"');
  2892.         if (gh->CurrentPos) {
  2893.             *(gh->CurrentPos) = 0;
  2894.             gh->CurrentValue->VNode.ln_Name = mystrdup(gh,s);
  2895.             temp = TextLength(&(gh->MyScreen->RastPort),s,strlen(s))+(GADGETWIDTH+INTERWIDTH);
  2896.             if (temp > gh->rightsize) {
  2897.                 gh->rightsize = temp;
  2898.             }
  2899.             temp = 8*strlen(s) + (GADGETWIDTH + INTERWIDTH);
  2900.             if (temp > gh->trightsize) {
  2901.                 gh->trightsize = temp;
  2902.             }
  2903.             ++(gh->CurrentPos);
  2904.         }
  2905.         else {
  2906.             pError(gh,GetMessage(MSG_ERR_CYCLEVEQ),NULL);
  2907.         }
  2908.     }
  2909.     else {
  2910.         pError(gh,GetMessage(MSG_ERR_CYCLEVSQ),NULL);
  2911.     }
  2912. }
  2913.  
  2914. void
  2915. GetCycleParameter(struct MPGuiHandle *gh) {
  2916.     char *s;
  2917.     if (gh->CurrentPos) {
  2918.         gh->CurrentPos = strchr(gh->CurrentPos,'"');
  2919.         if (gh->CurrentPos) {
  2920.             s = gh->CurrentPos + 1;
  2921.             gh->CurrentPos = strchr(s,'"');
  2922.             if (gh->CurrentPos) {
  2923.                 *(gh->CurrentPos) = 0;
  2924.                 gh->CurrentValue->Prefix = mystrdup(gh,s);
  2925.                 ++(gh->CurrentPos);
  2926.             }
  2927.             else {
  2928.                 pError(gh,GetMessage(MSG_ERR_CYCLEPEQ),NULL);
  2929.             }
  2930.         }
  2931.         else {
  2932.             pError(gh,GetMessage(MSG_ERR_CYCLEPSQ),NULL);
  2933.         }
  2934.     }
  2935. }
  2936.  
  2937. void
  2938. GetListTitle(struct MPGuiHandle *gh) {
  2939.     char *s;
  2940.     int temp;
  2941.     gh->CurrentPos = strchr(gh->buffer,'"');
  2942.     if (gh->CurrentPos) {
  2943.         s = gh->CurrentPos + 1;
  2944.         gh->CurrentPos = strchr(s,'"');
  2945.         if (gh->CurrentPos) {
  2946.             *(gh->CurrentPos) = 0;
  2947.             gh->CurrentValue->VNode.ln_Name = mystrdup(gh,s);
  2948.             temp = TextLength(&(gh->MyScreen->RastPort),s,strlen(s))+(GADGETWIDTH+INTERWIDTH);
  2949.             if (temp > gh->rightsize) {
  2950.                 gh->rightsize = temp;
  2951.             }
  2952.             temp = 8*strlen(s) + (GADGETWIDTH + INTERWIDTH);
  2953.             if (temp > gh->trightsize) {
  2954.                 gh->trightsize = temp;
  2955.             }
  2956.             ++(gh->CurrentPos);
  2957.         }
  2958.         else {
  2959.             pError(gh,GetMessage(MSG_ERR_LISTVEQ),NULL);
  2960.         }
  2961.     }
  2962.     else {
  2963.         pError(gh,GetMessage(MSG_ERR_LISTVSQ),NULL);
  2964.     }
  2965. }
  2966.  
  2967. void
  2968. GetListParameter(struct MPGuiHandle *gh) {
  2969.     char *s;
  2970.     if (gh->CurrentPos) {
  2971.         gh->CurrentPos = strchr(gh->CurrentPos,'"');
  2972.         if (gh->CurrentPos) {
  2973.             s = gh->CurrentPos + 1;
  2974.             gh->CurrentPos = strchr(s,'"');
  2975.             if (gh->CurrentPos) {
  2976.                 *(gh->CurrentPos) = 0;
  2977.                 gh->CurrentValue->Prefix = mystrdup(gh,s);
  2978.                 ++(gh->CurrentPos);
  2979.             }
  2980.             else {
  2981.                 pError(gh,GetMessage(MSG_ERR_MLISTVPE),NULL);
  2982.             }
  2983.         }
  2984.         else {
  2985.             pError(gh,GetMessage(MSG_ERR_MLISTVPS),NULL);
  2986.         }
  2987.     }
  2988. }
  2989.  
  2990. void
  2991. GetListNParameter(struct MPGuiHandle *gh) {
  2992.     char *s;
  2993.     if (gh->CurrentPos) {
  2994.         s = strchr(gh->CurrentPos,'"');
  2995.         if (s) {
  2996.             gh->CurrentPos = s;
  2997.             s = gh->CurrentPos + 1;
  2998.             gh->CurrentPos = strchr(s,'"');
  2999.             if (gh->CurrentPos) {
  3000.                 *(gh->CurrentPos) = 0;
  3001.                 gh->CurrentValue->NPrefix = mystrdup(gh,s);
  3002.                 ++(gh->CurrentPos);
  3003.             }
  3004.             else {
  3005.                 pError(gh,GetMessage(MSG_ERR_MLISTENQ),NULL);
  3006.             }
  3007.         }
  3008.     }
  3009. }
  3010.  
  3011. void
  3012. GetHelp(struct MPGuiHandle *gh) {
  3013.     char *s;
  3014.     if (gh->CurrentPos) {
  3015.         gh->CurrentPos = strchr(gh->CurrentPos,'!');
  3016.         if (gh->CurrentPos) {
  3017.             s = gh->CurrentPos + 1;
  3018.             gh->CurrentPos = strchr(s,'!');
  3019.             if (gh->CurrentPos) {
  3020.                 *(gh->CurrentPos) = 0;
  3021.                 gh->CurrentGadget->HelpNode = mystrdup(gh,s);
  3022.                 ++(gh->CurrentPos);
  3023.                 if (*gh->CurrentPos) {
  3024.                     s = gh->CurrentPos;
  3025.                     gh->CurrentPos = strchr(s,'!');
  3026.                     if (gh->CurrentPos) {
  3027.                         *(gh->CurrentPos) = 0;
  3028.                         gh->CurrentGadget->HelpMessage = mystrdup(gh,s);
  3029.                         gh->HelpMessageB = TRUE;
  3030.                         ++(gh->CurrentPos);
  3031.                     }
  3032.                     else {
  3033.                         pError(gh,GetMessage(MSG_ERR_ENDMP),NULL);
  3034.                     }
  3035.                 }
  3036.             }
  3037.             else {
  3038.                 pError(gh,GetMessage(MSG_ERR_ENDNP),NULL);
  3039.             }
  3040.         }
  3041.     }
  3042. }
  3043.  
  3044. char
  3045. *SkipSpace(char *s) {
  3046.     while (s && *s && ((*s == ' ') || (*s == '\t'))) {
  3047.         ++s;
  3048.     }
  3049.     return s;
  3050. }
  3051.  
  3052. #define USEROK            ((struct MyGadgetPtr *)(-1))
  3053. #define USERSAVE        USEROK
  3054. #define USERCANCEL    ((struct MyGadgetPtr *)(-2))
  3055. #define USERHELP        ((struct MyGadgetPtr *)(-3))
  3056. #define USERUSE        ((struct MyGadgetPtr *)(-4))
  3057. #define USERMESSAGE    ((struct MyGadgetPtr *)(-5))
  3058.  
  3059. void
  3060. RequesterStuff(struct MPGuiHandle *gh) {
  3061.     struct MyGadgetPtr *Ptr=0;
  3062.     struct MyGadget *MyGadget=0,*LoopGadget;
  3063.     struct MyValue *val;
  3064.     short notdone = 1;
  3065.     LONG left=0;
  3066.     LONG top=0;
  3067.     BOOL relmouse=FALSE;
  3068.     BOOL doit;
  3069.     struct TagItem *tag;
  3070.     struct MyGadget *HelpGadget=NULL,*oldHelpGadget=(struct MyGadget *)-1;
  3071.     ULONG Signals;
  3072.     char *p;
  3073.     char *HelpMessage;
  3074.     int i;
  3075.  
  3076.     if (gh->VisInfo = GetVisualInfo(gh->MyScreen,NULL)) {
  3077.         if (CreateContext(&(gh->Context))) {
  3078.             if (CreateGadgets(gh)) {
  3079.                 if (tag = FindTagItem(MPG_RELMOUSE,gh->TagList)) {
  3080.                     if (tag->ti_Data) {
  3081.                         relmouse = TRUE;
  3082.                         left = gh->MyScreen->MouseX - gh->width/2;
  3083.                         if (left < 0) {
  3084.                             left = 0;
  3085.                         }
  3086.                         top = gh->MyScreen->MouseY - gh->height/2;
  3087.                         if (top < 0) {
  3088.                             top = 0;
  3089.                         }
  3090.                     }
  3091.                 }
  3092.                 gh->Zoom[0] = (USHORT)~0;
  3093.                 gh->Zoom[1] = (USHORT)~0;
  3094.                 gh->Zoom[2] = gh->TitleLength + (GADGETWIDTH * 3 + INTERWIDTH);
  3095.                 gh->Zoom[3] = gh->MyScreen->WBorTop + gh->MyScreen->Font->ta_YSize + 1;
  3096.                 if (gh->Window = OpenWindowTags(NULL,
  3097.                        WA_Flags,      WFLG_DRAGBAR|
  3098.                                      WFLG_DEPTHGADGET|
  3099.                                        WFLG_CLOSEGADGET|
  3100.                                             WFLG_SMART_REFRESH|
  3101.                                          WFLG_ACTIVATE,
  3102.                     WA_IDCMP,       BUTTONIDCMP|
  3103.                                         CHECKBOXIDCMP|
  3104.                                         INTEGERIDCMP|
  3105.                                         CYCLEIDCMP|
  3106.                                         SLIDERIDCMP|
  3107.                                         STRINGIDCMP|
  3108.                                         LISTVIEWIDCMP|
  3109.                                      IDCMP_CLOSEWINDOW|
  3110.                                       IDCMP_VANILLAKEY|
  3111.                                       IDCMP_RAWKEY|
  3112.                                       IDCMP_REFRESHWINDOW|
  3113.                                       IDCMP_GADGETHELP|
  3114.                                       (gh->MenuFunc?IDCMP_MENUPICK:0)|
  3115.                                       ((gh->MenuFunc&&gh->HelpFunc)?IDCMP_MENUHELP:0),
  3116.                        WA_Width,       gh->width,
  3117.                    WA_Height,      gh->height,
  3118.                      WA_Title,        gh->Comment,
  3119.                      WA_AutoAdjust,TRUE,
  3120.                      WA_PubScreen,    gh->MyScreen,
  3121.                      WA_Gadgets,    gh->Context,
  3122.                      WA_Zoom,         gh->Zoom,
  3123.                      relmouse?WA_Left:TAG_IGNORE,    left,
  3124.                      relmouse?WA_Top:TAG_IGNORE,    top,
  3125.                      WA_MenuHelp,    gh->HelpFunc?TRUE:FALSE,
  3126.                      WA_NewLookMenus,TRUE,
  3127.                      gh->Check ? WA_Checkmark: TAG_IGNORE,    gh->Check,
  3128.                      gh->Amiga ? WA_AmigaKey : TAG_IGNORE,    gh->Amiga,
  3129.                      TAG_END)) {
  3130.                     // Enable gadget Help
  3131.                     HelpControl(gh->Window,HC_GADGETHELP);
  3132.                     if (gh->NewMenu) {
  3133.                         if (gh->Menu = CreateMenus( gh->NewMenu, TAG_DONE )) {
  3134.                             LayoutMenus( gh->Menu, gh->VisInfo, 
  3135.                                             GTMN_NewLookMenus,TRUE,
  3136.                                             gh->Check ? GTMN_Checkmark : TAG_IGNORE, gh->Check,
  3137.                                             gh->Amiga ? GTMN_AmigaKey : TAG_IGNORE, gh->Amiga,
  3138.                                             TAG_DONE );
  3139.                             SetMenuStrip( gh->Window, gh->Menu);
  3140.                         }
  3141.                     }
  3142.                     GT_RefreshWindow(gh->Window,NULL);
  3143.                     if (gh->CHelp && gh->HelpFunc) {
  3144.                         if (gh->HelpNode) {
  3145.                             MyCallHookPkt(gh,gh->HelpFunc,gh->HelpNode,NULL);
  3146.                         }
  3147.                     }
  3148.                     while (notdone) {
  3149.                      Signals = Wait((1L << gh->Window->UserPort->mp_SigBit) |
  3150.                                           (gh->Signals));
  3151.                      if (Signals & gh->Signals) {
  3152.                         if (gh->SignalFunc) {
  3153.                             notdone = MyCallHookPkt(gh,gh->SignalFunc,(APTR)Signals,NULL);
  3154.                             if (!notdone) {
  3155.                                 gh->result[0] = 0;
  3156.                             }
  3157.                         }
  3158.                      }
  3159.                      else {
  3160.                         while (gh->IntuiMsg = GT_GetIMsg(gh->Window->UserPort)) {
  3161.                             switch (gh->IntuiMsg->Class) {
  3162.                             case IDCMP_MENUPICK:
  3163.                                 if (gh->MenuFunc) {
  3164.                                     notdone = MyCallHookPkt(gh,gh->MenuFunc,gh->IntuiMsg,gh->Menu);
  3165.                                 }
  3166.                                 break;
  3167.                             case IDCMP_MENUHELP:
  3168.                                 if (gh->MenuFunc && gh->HelpFunc) {
  3169.                                     MyCallHookPkt(gh,gh->MenuFunc,gh->IntuiMsg,gh->Menu);
  3170.                                 }
  3171.                                 break;
  3172.                             case IDCMP_RAWKEY:
  3173.                                 if (gh->IntuiMsg->Code == 0x5f) {
  3174.                                     if (gh->HelpFunc) {
  3175.                                         if (HelpGadget && HelpGadget->HelpNode) {
  3176.                                             MyCallHookPkt(gh,gh->HelpFunc,HelpGadget->HelpNode,NULL);
  3177.                                         }
  3178.                                         else {
  3179.                                             if (gh->HelpNode) {
  3180.                                                 MyCallHookPkt(gh,gh->HelpFunc,gh->HelpNode,NULL);
  3181.                                             }
  3182.                                         }
  3183.                                     }
  3184.                                 }
  3185.                                 break;
  3186.                             case IDCMP_GADGETHELP:
  3187.                                  if (gh->IntuiMsg->IAddress == NULL) {
  3188.                                      HelpGadget = NULL;
  3189.                                      HelpMessage = gh->HelpMessage;
  3190.                                  }
  3191.                                  else {
  3192.                                      if (gh->IntuiMsg->IAddress == gh->Window) {
  3193.                                          HelpGadget = NULL;
  3194.                                          HelpMessage = gh->HelpMessage;
  3195.                                      }
  3196.                                      else {
  3197.                                          if (!(((struct Gadget *)gh->IntuiMsg->IAddress)->GadgetType & GTYP_SYSGADGET)) {    // Not a system gadget
  3198.                                             Ptr = (struct MyGadgetPtr *)((struct Gadget *)gh->IntuiMsg->IAddress)->UserData;
  3199.                                             if (Ptr == USERSAVE && gh->Prefs) {
  3200.                                                 HelpGadget = NULL;
  3201.                                                 HelpMessage = GetMessage(MSG_HELPSAVE);
  3202.                                             }
  3203.                                             else if (Ptr == USEROK && !gh->Prefs) {
  3204.                                                 HelpGadget = NULL;
  3205.                                                 HelpMessage = GetMessage(MSG_HELPOK);
  3206.                                             }
  3207.                                             else if (Ptr == USERUSE) {
  3208.                                                 HelpGadget = NULL;
  3209.                                                 HelpMessage = GetMessage(MSG_HELPUSE);
  3210.                                             }
  3211.                                             else if (Ptr == USERCANCEL && gh->Prefs) {
  3212.                                                 HelpGadget = NULL;
  3213.                                                 HelpMessage = GetMessage(MSG_HELPCANCELP);
  3214.                                             }
  3215.                                             else if (Ptr == USERCANCEL && !gh->Prefs) {
  3216.                                                 HelpGadget = NULL;
  3217.                                                 HelpMessage = GetMessage(MSG_HELPCANCELR);
  3218.                                             }
  3219.                                             else if (Ptr == USERHELP) {
  3220.                                                 HelpGadget = NULL;
  3221.                                                 HelpMessage = GetMessage(MSG_HELPHELPB);
  3222.                                             }
  3223.                                             else if (Ptr == USERMESSAGE) {
  3224.                                                 HelpGadget = NULL;
  3225.                                                 HelpMessage = GetMessage(MSG_HELPHELPG);
  3226.                                             }
  3227.                                             else if (Ptr) {
  3228.                                                 HelpGadget = Ptr->MyGadget;
  3229.                                                 HelpMessage = HelpGadget->HelpMessage;
  3230.                                             }
  3231.                                             else {
  3232.                                                 HelpGadget = NULL;
  3233.                                                  HelpMessage = gh->HelpMessage;
  3234.                                             }
  3235.                                          }
  3236.                                          else {
  3237.                                              switch (((struct Gadget *)gh->IntuiMsg->IAddress)->GadgetType & GTYP_SYSTYPEMASK) {
  3238.                                              case GTYP_WDRAGGING:
  3239.                                                  HelpMessage = GetMessage(MSG_HELPDRAG);
  3240.                                                  break;
  3241.                                              case GTYP_WUPFRONT:
  3242.                                                  HelpMessage = GetMessage(MSG_HELPFRONT);
  3243.                                                  break;
  3244.                                              case GTYP_WDOWNBACK:
  3245.                                                  HelpMessage = GetMessage(MSG_HELPZOOM);
  3246.                                                  break;
  3247.                                              case GTYP_CLOSE:
  3248.                                                  if (gh->Prefs) {
  3249.                                                      HelpMessage = GetMessage(MSG_HELPCANCELP);
  3250.                                                  }
  3251.                                                  else {
  3252.                                                     HelpMessage = GetMessage(MSG_HELPCANCELR);
  3253.                                                  }
  3254.                                                  break;
  3255.                                              default:
  3256.                                                  HelpMessage = gh->HelpMessage;
  3257.                                                  break;
  3258.                                              }
  3259.                                              HelpGadget = NULL;
  3260.                                          }
  3261.                                      }
  3262.                                  }
  3263.                                  if (!HelpMessage) {
  3264.                                      HelpMessage = gh->HelpMessage;
  3265.                                 }
  3266.                                 if (gh->HelpMessageB) {
  3267.                                     GT_SetGadgetAttrs(gh->HelpGadget,gh->Window,NULL,
  3268.                                                             GTTX_Text,HelpMessage,
  3269.                                                             TAG_END);
  3270.                                 }
  3271.                                  if (gh->CHelp && gh->HelpFunc) {
  3272.                                      if (oldHelpGadget != HelpGadget) {
  3273.                                         if (HelpGadget && HelpGadget->HelpNode) {
  3274.                                             MyCallHookPkt(gh,gh->HelpFunc,HelpGadget->HelpNode,NULL);
  3275.                                         }
  3276.                                         else {
  3277.                                             if (gh->HelpNode) {
  3278.                                                 MyCallHookPkt(gh,gh->HelpFunc,gh->HelpNode,NULL);
  3279.                                             }
  3280.                                         }
  3281.                                         oldHelpGadget = HelpGadget;
  3282.                                     }
  3283.                                 }
  3284.                                 break;
  3285.                             case IDCMP_REFRESHWINDOW:
  3286.                                 GT_BeginRefresh(gh->Window);
  3287.                                 GT_EndRefresh(gh->Window,TRUE);
  3288.                                 break;
  3289.                             case IDCMP_CLOSEWINDOW:
  3290.                                 notdone = 0;
  3291.                                 break;
  3292.                             case IDCMP_VANILLAKEY:
  3293.                             case IDCMP_GADGETUP:
  3294.                                 if ((gh->IntuiMsg->Class == IDCMP_GADGETUP) &&
  3295.                                      (gh->IntuiMsg->Code == 0x5F)) {    // Help key in string
  3296.                                     Ptr = (struct MyGadgetPtr *)((struct Gadget *)gh->IntuiMsg->IAddress)->UserData;
  3297.                                     // Cant be Ok, Help, Cancel, Save, Use
  3298.                                     HelpGadget = Ptr->MyGadget;
  3299.                                     if (gh->HelpFunc) {
  3300.                                         if (HelpGadget && HelpGadget->HelpNode) {
  3301.                                             MyCallHookPkt(gh,gh->HelpFunc,HelpGadget->HelpNode,NULL);
  3302.                                         }
  3303.                                         else {
  3304.                                             if (gh->HelpNode) {
  3305.                                                 MyCallHookPkt(gh,gh->HelpFunc,gh->HelpNode,NULL);
  3306.                                             }
  3307.                                         }
  3308.                                     }
  3309.                                     ActivateGadget((struct Gadget *)gh->IntuiMsg->IAddress,gh->Window,NULL);
  3310.                                     doit = FALSE;
  3311.                                 }
  3312.                                 else {
  3313.                                     if (gh->IntuiMsg->Class == IDCMP_VANILLAKEY) {
  3314.                                         doit = FALSE;
  3315.                                         if ((gh->IntuiMsg->Code == 0x1B) && !gh->Prefs) {
  3316.                                             Ptr = USERCANCEL;
  3317.                                             notdone = 0;
  3318.                                         }
  3319.                                         if (!gh->NoButtons) {
  3320.                                             if (!gh->NoOk && (toupper(gh->IntuiMsg->Code) == OKCHAR) && !gh->Prefs) {
  3321.                                                 doit = TRUE;
  3322.                                                 Ptr = USEROK;
  3323.                                             }
  3324.                                             else if (!gh->NoSave && (toupper(gh->IntuiMsg->Code) == SAVECHAR) && gh->Prefs) {
  3325.                                                 doit = TRUE;
  3326.                                                 Ptr = USERSAVE;
  3327.                                                 gh->Response = MPG_SAVE;
  3328.                                             }
  3329.                                             else if (!gh->NoUse && (toupper(gh->IntuiMsg->Code) == USECHAR) && gh->Prefs) {
  3330.                                                 doit = TRUE;
  3331.                                                 Ptr = USERUSE;
  3332.                                                 gh->Response = MPG_USE;
  3333.                                             }
  3334.                                             else if (!gh->NoCancel && toupper(gh->IntuiMsg->Code) == CANCELCHAR) {
  3335.                                                 notdone = 0;
  3336.                                             }
  3337.                                         }
  3338.                                         if (notdone && !doit) {
  3339.                                             for (LoopGadget = (struct MyGadget *)(gh->GList.lh_Head);
  3340.                                                     LoopGadget->GNode.ln_Succ;
  3341.                                                     LoopGadget = (struct MyGadget *)(LoopGadget->GNode.ln_Succ)) {
  3342.                                                 if (toupper(gh->IntuiMsg->Code) == LoopGadget->Char) {
  3343.                                                     doit = TRUE;
  3344.                                                     Ptr = &(LoopGadget->Ptr1);
  3345.                                                 }
  3346.                                             }
  3347.                                         }
  3348.                                     }
  3349.                                     else {
  3350.                                         Ptr = (struct MyGadgetPtr *)((struct Gadget *)gh->IntuiMsg->IAddress)->UserData;
  3351.                                         doit = TRUE;
  3352.                                         if (Ptr == USERSAVE) {
  3353.                                             gh->Response = MPG_SAVE;
  3354.                                         }
  3355.                                         else {
  3356.                                             if (Ptr == USERUSE) {
  3357.                                                 gh->Response = MPG_USE;
  3358.                                             }
  3359.                                         }
  3360.                                     }
  3361.                                     if (Ptr == USERCANCEL) {    // Cancel gadget
  3362.                                         notdone = 0;
  3363.                                         doit = FALSE;
  3364.                                     }
  3365.                                     else {
  3366.                                         if (Ptr == USERHELP) {    // Help gadget
  3367.                                             if (gh->HelpFunc && gh->HelpNode) {
  3368.                                                 MyCallHookPkt(gh,gh->HelpFunc,gh->HelpNode,NULL);
  3369.                                             }
  3370.                                             doit = FALSE;
  3371.                                         }
  3372.                                     }
  3373.                                 }
  3374.                                 if (((Ptr == USERSAVE) || (Ptr == USERUSE)) && doit) {
  3375.                                     MPGuiCurrentAttrs(gh);
  3376.                                     notdone = 0;
  3377.                                 }
  3378.                                 else {
  3379.                                     if (doit) {
  3380.                                         MyGadget = Ptr->MyGadget;
  3381.                                         if (MyGadget->OwnCycle) {
  3382.                                             if (MyGadget->OwnCycle->Currenty != MyGadget->Activey) {
  3383.                                                 doit = FALSE;
  3384.                                             }
  3385.                                         }
  3386.                                     }
  3387.                                     if (doit) {
  3388.                                         switch (MyGadget->Type) {
  3389.                                         case GAD_FILE:
  3390.                                         case GAD_LFILE:
  3391.                                         case GAD_SFILE:
  3392.                                             if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3393.                                                  (!(gh->IntuiMsg->Qualifier & IEQUALIFIER_RSHIFT))) {
  3394.                                                 ActivateGadget(MyGadget->Gadget1,gh->Window,NULL);
  3395.                                             }
  3396.                                             else {
  3397.                                                 if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) ||
  3398.                                                      (Ptr->Number == 2)) {
  3399.                                                     GT_GetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3400.                                                             GTST_String,&p,
  3401.                                                             TAG_END);
  3402.                                                     if (GetAFile(gh,p,
  3403.                                                          (MyGadget->Type == GAD_LFILE)?GetMessage(MSG_SELECTINPUT):
  3404.                                                          (MyGadget->Type == GAD_SFILE)?GetMessage(MSG_SELECTOUTPUT):
  3405.                                                          GetMessage(MSG_SELECTFILE),
  3406.                                                          (MyGadget->Type == GAD_SFILE)?FRF_DOSAVEMODE:0,
  3407.                                                          (MyGadget->Type == GAD_LFILE)?GetMessage(MSG_INPUT):
  3408.                                                          (MyGadget->Type == GAD_SFILE)?GetMessage(MSG_OUTPUT):
  3409.                                                          GetMessage(MSG_SELECT))) {
  3410.                                                         GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3411.                                                             GTST_String,gh->TempFileName,
  3412.                                                             TAG_END);
  3413.                                                     }
  3414.                                                 }
  3415.                                             }
  3416.                                             break;
  3417.                                         case GAD_OFILE:
  3418.                                             if (((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3419.                                                   (!(gh->IntuiMsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT)))) ||
  3420.                                                  ((gh->IntuiMsg->Class == IDCMP_GADGETUP) &&
  3421.                                                   (Ptr->Number == 1))) {
  3422.                                                 MyGadget->Currentc = !MyGadget->Currentc;
  3423.                                                 GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3424.                                                         GTCB_Checked, MyGadget->Currentc,
  3425.                                                         TAG_END);
  3426.                                                 GT_SetGadgetAttrs(MyGadget->Gadget2,gh->Window,NULL,
  3427.                                                         GA_Disabled,!MyGadget->Currentc,
  3428.                                                         TAG_END);
  3429.                                                 GT_SetGadgetAttrs(MyGadget->Gadget3,gh->Window,NULL,
  3430.                                                         GA_Disabled,!MyGadget->Currentc,
  3431.                                                         TAG_END);
  3432.                                                 if (MyGadget->Currentc) {
  3433.                                                     ActivateGadget(MyGadget->Gadget2,gh->Window,NULL);
  3434.                                                 }
  3435.                                             }
  3436.                                             else {
  3437.                                                 if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3438.                                                      (gh->IntuiMsg->Qualifier & IEQUALIFIER_LSHIFT)) {
  3439.                                                     if (MyGadget->Currentc) {
  3440.                                                         ActivateGadget(MyGadget->Gadget2,gh->Window,NULL);
  3441.                                                     }
  3442.                                                 }
  3443.                                                 else {
  3444.                                                     if (((gh->IntuiMsg->Class == IDCMP_GADGETUP) &&
  3445.                                                          (Ptr->Number == 3)) ||
  3446.                                                         ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3447.                                                           (gh->IntuiMsg->Qualifier & IEQUALIFIER_RSHIFT) &&
  3448.                                                           (MyGadget->Currentc))) {
  3449.                                                         GT_GetGadgetAttrs(MyGadget->Gadget2,gh->Window,NULL,
  3450.                                                                 GTST_String,&p,
  3451.                                                                 TAG_END);
  3452.                                                         if (GetAFile(gh,p,
  3453.                                                              GetMessage(MSG_SELECTFILE),0,GetMessage(MSG_SELECT))) {
  3454.                                                             GT_SetGadgetAttrs(MyGadget->Gadget2,gh->Window,NULL,
  3455.                                                                 GTST_String,gh->TempFileName,
  3456.                                                                 TAG_END);
  3457.                                                         }
  3458.                                                     }
  3459.                                                 }
  3460.                                             }
  3461.                                             break;
  3462.                                         case GAD_MODE:
  3463.                                             if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) ||
  3464.                                                   (Ptr->Number == 2)) {
  3465.                                                 GT_GetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3466.                                                         GTTX_Text,&p,
  3467.                                                         TAG_END);
  3468.                                                 if (GetAMode(gh,MyGadget,p,
  3469.                                                         GetMessage(MSG_SELECTMODE))) {
  3470.                                                     GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3471.                                                         GTTX_Text,gh->TempFileName,
  3472.                                                         TAG_END);
  3473.                                                 }
  3474.                                             }
  3475.                                             break;
  3476.                                         case GAD_OMODE:
  3477.                                         case GAD_OFONT:
  3478.                                             if (((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3479.                                                   (!(gh->IntuiMsg->Qualifier & IEQUALIFIER_RSHIFT))) ||
  3480.                                                  ((gh->IntuiMsg->Class == IDCMP_GADGETUP) &&
  3481.                                                   (Ptr->Number == 1))) {
  3482.                                                 MyGadget->Currentc = !MyGadget->Currentc;
  3483.                                                 GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3484.                                                         GTCB_Checked, MyGadget->Currentc,
  3485.                                                         TAG_END);
  3486.                                                 GT_SetGadgetAttrs(MyGadget->Gadget2,gh->Window,NULL,
  3487.                                                         GA_Disabled,!MyGadget->Currentc,
  3488.                                                         TAG_END);
  3489.                                                 GT_SetGadgetAttrs(MyGadget->Gadget3,gh->Window,NULL,
  3490.                                                         GA_Disabled,!MyGadget->Currentc,
  3491.                                                         TAG_END);
  3492.                                             }
  3493.                                             else {
  3494.                                                 if (((gh->IntuiMsg->Class == IDCMP_GADGETUP) &&
  3495.                                                      (Ptr->Number == 3)) ||
  3496.                                                     ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3497.                                                       (gh->IntuiMsg->Qualifier & IEQUALIFIER_RSHIFT) &&
  3498.                                                       (MyGadget->Currentc))) {
  3499.                                                     GT_GetGadgetAttrs(MyGadget->Gadget2,gh->Window,NULL,
  3500.                                                             GTTX_Text,&p,
  3501.                                                             TAG_END);
  3502.                                                     switch (MyGadget->Type) {
  3503.                                                     case GAD_OMODE:
  3504.                                                         if (GetAMode(gh,MyGadget,p,
  3505.                                                                 GetMessage(MSG_SELECTMODE))) {
  3506.                                                             GT_SetGadgetAttrs(MyGadget->Gadget2,gh->Window,NULL,
  3507.                                                                 GTTX_Text,gh->TempFileName,
  3508.                                                                 TAG_END);
  3509.                                                         }
  3510.                                                         break;
  3511.                                                     case GAD_OFONT:
  3512.                                                         if (GetAFont(gh,MyGadget,p,
  3513.                                                                 GetMessage(MSG_SELECTFONT))) {
  3514.                                                             GT_SetGadgetAttrs(MyGadget->Gadget2,gh->Window,NULL,
  3515.                                                                 GTTX_Text,gh->TempFileName,
  3516.                                                                 TAG_END);
  3517.                                                         }
  3518.                                                         break;
  3519.                                                     }
  3520.                                                 }
  3521.                                             }
  3522.                                             break;
  3523.                                         case GAD_FONT:
  3524.                                             if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) ||
  3525.                                                   (Ptr->Number == 2)) {
  3526.                                                 GT_GetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3527.                                                         GTTX_Text,&p,
  3528.                                                         TAG_END);
  3529.                                                 if (GetAFont(gh,MyGadget,p,
  3530.                                                         GetMessage(MSG_SELECTFONT))) {
  3531.                                                     GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3532.                                                         GTTX_Text,gh->TempFileName,
  3533.                                                         TAG_END);
  3534.                                                 }
  3535.                                             }
  3536.                                             break;
  3537.                                         case GAD_ONUMBER:
  3538.                                         case GAD_OSTRING:
  3539.                                             if (((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3540.                                                   (!(gh->IntuiMsg->Qualifier & IEQUALIFIER_LSHIFT))) ||
  3541.                                                  ((gh->IntuiMsg->Class == IDCMP_GADGETUP) &&
  3542.                                                   (Ptr->Number == 1))) {
  3543.                                                 MyGadget->Currentc = !MyGadget->Currentc;
  3544.                                                 GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3545.                                                         GTCB_Checked, MyGadget->Currentc,
  3546.                                                         TAG_END);
  3547.                                                 GT_SetGadgetAttrs(MyGadget->Gadget2,gh->Window,NULL,
  3548.                                                         GA_Disabled,!MyGadget->Currentc,
  3549.                                                         TAG_END);
  3550.                                                 if (MyGadget->Currentc) {
  3551.                                                     ActivateGadget(MyGadget->Gadget2,gh->Window,NULL);
  3552.                                                 }
  3553.                                             }
  3554.                                             else {
  3555.                                                 if (gh->IntuiMsg->Class == IDCMP_VANILLAKEY) {
  3556.                                                     if (MyGadget->Currentc) {
  3557.                                                         ActivateGadget(MyGadget->Gadget2,gh->Window,NULL);
  3558.                                                     }
  3559.                                                 }
  3560.                                             }
  3561.                                             break;
  3562.                                         case GAD_NUMBER:
  3563.                                         case GAD_STRING:
  3564.                                             if (gh->IntuiMsg->Class == IDCMP_VANILLAKEY) {
  3565.                                                 ActivateGadget(MyGadget->Gadget1,gh->Window,NULL);
  3566.                                             }
  3567.                                             break;
  3568.                                         case GAD_LIST:
  3569.                                             if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3570.                                                  (gh->IntuiMsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))) {
  3571.                                                 if (!MyGadget->Currenty) {
  3572.                                                     MyGadget->Currenty = MyGadget->Numbery - 1;
  3573.                                                 }
  3574.                                                 else {
  3575.                                                     MyGadget->Currenty -= 1;
  3576.                                                 }
  3577.                                             }
  3578.                                             else {
  3579.                                                 if (gh->IntuiMsg->Class == IDCMP_VANILLAKEY) {
  3580.                                                     ++MyGadget->Currenty;
  3581.                                                     if (MyGadget->Currenty == MyGadget->Numbery) {
  3582.                                                         MyGadget->Currenty = 0;
  3583.                                                     }
  3584.                                                 }
  3585.                                                 else {
  3586.                                                     MyGadget->Currenty = gh->IntuiMsg->Code;
  3587.                                                 }
  3588.                                             }
  3589.                                             GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3590.                                                             GTLV_Selected, MyGadget->Currenty,
  3591.                                                             GTLV_MakeVisible, MyGadget->Currenty,
  3592.                                                             TAG_END);
  3593.                                             break;
  3594.                                         case GAD_MLIST:
  3595.                                             if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3596.                                                  !(gh->IntuiMsg->Qualifier & IEQUALIFIER_RSHIFT)) {
  3597.                                                 if (gh->IntuiMsg->Qualifier & IEQUALIFIER_LSHIFT) {
  3598.                                                     if (!MyGadget->Currenty) {
  3599.                                                         MyGadget->Currenty = MyGadget->Numbery - 1;
  3600.                                                     }
  3601.                                                     else {
  3602.                                                         MyGadget->Currenty -= 1;
  3603.                                                     }
  3604.                                                 }
  3605.                                                 else {
  3606.                                                     ++MyGadget->Currenty;
  3607.                                                     if (MyGadget->Currenty == MyGadget->Numbery) {
  3608.                                                         MyGadget->Currenty = 0;
  3609.                                                     }
  3610.                                                 }
  3611.                                                 GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3612.                                                             GTLV_Selected, MyGadget->Currenty,
  3613.                                                             GTLV_MakeVisible, MyGadget->Currenty,
  3614.                                                             TAG_END);
  3615.                                             }
  3616.                                             else {
  3617.                                                 GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3618.                                                                 GTLV_Labels, -1,
  3619.                                                                 TAG_END);
  3620.                                                 if (gh->IntuiMsg->Class != IDCMP_VANILLAKEY) {
  3621.                                                     MyGadget->Currenty = gh->IntuiMsg->Code;
  3622.                                                 }
  3623.                                                 val = (struct MyValue *)MyGadget->VList.lh_Head;
  3624.                                                 for (i=0; (i < MyGadget->Currenty); i++) {
  3625.                                                     val = (struct MyValue *)val->VNode.ln_Succ;
  3626.                                                 }
  3627.                                                 if (val->Selected) {
  3628.                                                     val->Selected = FALSE;
  3629.                                                 }
  3630.                                                 else {
  3631.                                                     val->Selected = TRUE;
  3632.                                                 }
  3633.                                                 GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3634.                                                                 GTLV_Labels,    &(MyGadget->VList),
  3635.                                                                 GTLV_Selected, MyGadget->Currenty,
  3636.                                                                 TAG_END);
  3637.                                             }
  3638.                                             break;
  3639.                                         case GAD_CYCLE:
  3640.                                             if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3641.                                                  (gh->IntuiMsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))) {
  3642.                                                 if (!MyGadget->Currenty) {
  3643.                                                     MyGadget->Currenty = MyGadget->Numbery - 1;
  3644.                                                 }
  3645.                                                 else {
  3646.                                                     MyGadget->Currenty -= 1;
  3647.                                                 }
  3648.                                             }
  3649.                                             else {
  3650.                                                 if (gh->IntuiMsg->Class == IDCMP_VANILLAKEY) {
  3651.                                                     ++MyGadget->Currenty;
  3652.                                                     if (MyGadget->Currenty == MyGadget->Numbery) {
  3653.                                                         MyGadget->Currenty = 0;
  3654.                                                     }
  3655.                                                 }
  3656.                                                 else {
  3657.                                                     MyGadget->Currenty = gh->IntuiMsg->Code;
  3658.                                                 }
  3659.                                             }
  3660.                                             GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3661.                                                         GTCY_Active, MyGadget->Currenty,
  3662.                                                         TAG_END);
  3663.                                             for (LoopGadget = (struct MyGadget *)(gh->GList.lh_Head);
  3664.                                                     LoopGadget->GNode.ln_Succ;
  3665.                                                     LoopGadget = (struct MyGadget *)(LoopGadget->GNode.ln_Succ)){
  3666.                                                 if (MyGadget == LoopGadget->OwnCycle) {
  3667.                                                     GT_SetGadgetAttrs(LoopGadget->Gadget1,gh->Window,NULL,
  3668.                                                             GA_Disabled,MyGadget->Currenty != LoopGadget->Activey,
  3669.                                                             TAG_END);
  3670.                                                     if (LoopGadget->Gadget2) {
  3671.                                                         GT_SetGadgetAttrs(LoopGadget->Gadget2,gh->Window,NULL,
  3672.                                                                 GA_Disabled,(MyGadget->Currenty != LoopGadget->Activey) ||
  3673.                                                                                 (((LoopGadget->Type == GAD_ONUMBER) ||
  3674.                                                                                   (LoopGadget->Type == GAD_OSTRING) ||
  3675.                                                                                   (LoopGadget->Type == GAD_OFILE)) && (!LoopGadget->Currentc)),
  3676.                                                                 TAG_END);
  3677.                                                     }
  3678.                                                     if (LoopGadget->Gadget3) {
  3679.                                                         GT_SetGadgetAttrs(LoopGadget->Gadget3,gh->Window,NULL,
  3680.                                                                 GA_Disabled,(MyGadget->Currenty != LoopGadget->Activey) ||
  3681.                                                                                   (((LoopGadget->Type == GAD_OFILE) ||
  3682.                                                                                     (LoopGadget->Type == GAD_OFONT) ||
  3683.                                                                                     (LoopGadget->Type == GAD_OMODE)) && (!LoopGadget->Currentc)),
  3684.                                                                 TAG_END);
  3685.                                                     }
  3686.                                                 }
  3687.                                             }
  3688.                                             break;
  3689.                                         case GAD_CHECK:
  3690.                                             MyGadget->Currentc = !MyGadget->Currentc;
  3691.                                             GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3692.                                                     GTCB_Checked, MyGadget->Currentc,
  3693.                                                     TAG_END);
  3694.                                             break;
  3695.                                         case GAD_SLIDER:
  3696.                                             if ((gh->IntuiMsg->Class == IDCMP_VANILLAKEY) &&
  3697.                                                  (gh->IntuiMsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))) {
  3698.                                                 if (MyGadget->Currentn > MyGadget->Minn) {
  3699.                                                     MyGadget->Currentn -= 1;
  3700.                                                 }
  3701.                                             }
  3702.                                             else {
  3703.                                                 if (gh->IntuiMsg->Class == IDCMP_VANILLAKEY) {
  3704.                                                     if (MyGadget->Currentn < MyGadget->Maxn) {
  3705.                                                         MyGadget->Currentn += 1;
  3706.                                                     }
  3707.                                                 }
  3708.                                                 else {
  3709.                                                     MyGadget->Currentn = gh->IntuiMsg->Code;
  3710.                                                 }
  3711.                                             }
  3712.                                             GT_SetGadgetAttrs(MyGadget->Gadget1,gh->Window,NULL,
  3713.                                                         GTSL_Level, MyGadget->Currentn,
  3714.                                                         TAG_END);
  3715.                                             break;
  3716.                                         case GAD_BUTTON:
  3717.                                             if (gh->ButtonFunc) {
  3718.                                                 notdone = MyCallHookPkt(gh,gh->ButtonFunc,gh,(APTR)MyGadget->ButtonNo);
  3719.                                             }
  3720.                                             break;
  3721.                                         }
  3722.                                     }
  3723.                                 }
  3724.                                 break;
  3725.                             default:
  3726.                                 break;
  3727.                             }
  3728.                             GT_ReplyIMsg(gh->IntuiMsg);
  3729.                         }
  3730.                      }
  3731.                     }
  3732.                     if (gh->Menu) {
  3733.                         ClearMenuStrip(gh->Window);
  3734.                         FreeMenus(gh->Menu);
  3735.                     }
  3736.                     CloseWindow(gh->Window);
  3737.                 }
  3738.             }
  3739.             FreeGadgets(gh->Context);
  3740.         }
  3741.         FreeVisualInfo(gh->VisInfo);
  3742.     }
  3743. }
  3744.  
  3745. /* Creates all the gadgets for a requester
  3746.  * Returns:        TRUE if everything worked
  3747.  */
  3748. BOOL
  3749. CreateGadgets(struct MPGuiHandle *gh) {
  3750.     struct MyGadget *MyGadget;
  3751.     struct Gadget *Gadget;
  3752.     struct NewGadget NewGadget = {
  3753.         0,0,
  3754.         0,0,
  3755.         NULL,
  3756.         NULL,
  3757.         PLACETEXT_IN,
  3758.         NULL,
  3759.         NULL
  3760.     };
  3761.     int CancelSize;
  3762.     int temp;
  3763.     int tleft = 0;
  3764.     BOOL InButton = FALSE;
  3765.     int ButtonNo = 0;    // Number of this gadget in ButtonText
  3766.     long ButtonWidth = 0;    // Set to get fixed width buttons
  3767.  
  3768.     if (gh->UseTopaz) {
  3769.         CancelSize = gh->XSize*strlen(GetMessage(MSG__CANCEL));
  3770.     }
  3771.     else {
  3772.         CancelSize = TextLength(&(gh->MyScreen->RastPort),GetMessage(MSG__CANCEL),strlen(GetMessage(MSG__CANCEL)));
  3773.     }
  3774.     if ((CancelSize + (gh->interwidth)) > gh->rightsize) {
  3775.         gh->rightsize = CancelSize+gh->interwidth;
  3776.     }
  3777.     if ((CancelSize) > gh->leftsize) {
  3778.         gh->leftsize = CancelSize;
  3779.     }
  3780.     if ((gh->HelpFunc && gh->HelpNode) || (gh->Prefs)) {
  3781.         if (((CancelSize + (gh->interwidth))*2) > gh->rightsize) {
  3782.             gh->rightsize = (CancelSize+gh->interwidth)*2;
  3783.         }
  3784.     }
  3785.     gh->width = gh->leftsize + gh->rightsize + (gh->interwidth * 2) +
  3786.               gh->MyScreen->WBorLeft + gh->MyScreen->WBorRight;
  3787.     if ((gh->TitleLength + (GADGETWIDTH * 3 + gh->interwidth)) > gh->width) {
  3788.         gh->width = gh->TitleLength + (GADGETWIDTH * 3 + gh->interwidth);
  3789.         temp = gh->width - gh->leftsize - gh->rightsize - (gh->interwidth * 2) -
  3790.                  gh->MyScreen->WBorLeft - gh->MyScreen->WBorRight;
  3791.         gh->leftsize += temp/2;
  3792.         gh->rightsize += temp/2;
  3793.     }
  3794.     Gadget = gh->Context;
  3795.     gh->height = gh->MyScreen->WBorTop + gh->MyScreen->Font->ta_YSize + 1;
  3796.     NewGadget.ng_Height = gh->MyTextAttr->ta_YSize + 4;
  3797.     NewGadget.ng_VisualInfo = gh->VisInfo;
  3798.     NewGadget.ng_TextAttr = gh->MyTextAttr;
  3799.     NewGadget.ng_Flags = PLACETEXT_LEFT;
  3800.     if (gh->HelpMessageB) {
  3801.         gh->height += gh->interheight;
  3802.         NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth;
  3803.         NewGadget.ng_Width = gh->rightsize + gh->leftsize;
  3804.         NewGadget.ng_TopEdge = gh->height;
  3805.         NewGadget.ng_UserData = (APTR)USERMESSAGE;
  3806.         gh->HelpGadget = Gadget = CreateGadget(TEXT_KIND,Gadget,&NewGadget,
  3807.                                         GTTX_Text, gh->HelpMessage,
  3808.                                         GTTX_Border, TRUE,
  3809.                                         TAG_END);
  3810.         gh->height += gh->MyTextAttr->ta_YSize + 2;
  3811.     }
  3812.     for (MyGadget = (struct MyGadget *)gh->GList.lh_Head;
  3813.             MyGadget->GNode.ln_Succ && Gadget;
  3814.             MyGadget = (struct MyGadget *)MyGadget->GNode.ln_Succ) {
  3815.         if (InButton &&
  3816.              (MyGadget->Type != GAD_BUTTON)) {
  3817.             gh->height += gh->MyTextAttr->ta_YSize + 2;
  3818.             InButton = FALSE;
  3819.         }
  3820.         if (!InButton) {
  3821.             gh->height += gh->interheight;
  3822.         }
  3823.         NewGadget.ng_TopEdge = gh->height;
  3824.         switch (MyGadget->Type) {
  3825.         case GAD_FILE:
  3826.         case GAD_LFILE:
  3827.         case GAD_SFILE:
  3828.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  3829.             MyGadget->Ptr1.MyGadget = MyGadget;
  3830.             MyGadget->Ptr1.Number = 1;
  3831.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  3832.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  3833.             NewGadget.ng_Width = gh->rightsize - (gh->interwidth/2 + GADGETWIDTH);
  3834.             NewGadget.ng_GadgetText = MyGadget->Title;
  3835.             MyGadget->Gadget1 = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  3836.                                         GTST_String, MyGadget->Defaults,
  3837.                                         GTST_MaxChars, 256,
  3838.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  3839.                                         GT_Underscore, '_',
  3840.                                         STRINGA_ExitHelp, TRUE,
  3841.                                         TAG_END);
  3842.             NewGadget.ng_LeftEdge += NewGadget.ng_Width + gh->interwidth/2;
  3843.             MyGadget->Ptr2.MyGadget = MyGadget;
  3844.             MyGadget->Ptr2.Number = 2;
  3845.             NewGadget.ng_UserData = &(MyGadget->Ptr2);
  3846.             NewGadget.ng_Width = GADGETWIDTH;
  3847.             NewGadget.ng_Flags = PLACETEXT_IN;
  3848.             NewGadget.ng_GadgetText = (char *)"«";
  3849.             MyGadget->Gadget2 = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  3850.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  3851.                                         TAG_END);
  3852.             NewGadget.ng_Flags = PLACETEXT_LEFT;
  3853.             break;
  3854.         case GAD_MODE:
  3855.         case GAD_FONT:
  3856.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  3857.             MyGadget->Ptr1.MyGadget = MyGadget;
  3858.             MyGadget->Ptr1.Number = 1;
  3859.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  3860.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  3861.             NewGadget.ng_Width = gh->rightsize - (gh->interwidth/2 + GADGETWIDTH);
  3862.             NewGadget.ng_GadgetText = MyGadget->Title;
  3863.             MyGadget->Gadget1 = Gadget = CreateGadget(TEXT_KIND,Gadget,&NewGadget,
  3864.                                         GTTX_Text, MyGadget->Defaults,
  3865.                                         GTTX_Border, TRUE,
  3866.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  3867.                                         GT_Underscore, '_',
  3868.                                         TAG_END);
  3869.             NewGadget.ng_LeftEdge += NewGadget.ng_Width + gh->interwidth/2;
  3870.             MyGadget->Ptr2.MyGadget = MyGadget;
  3871.             MyGadget->Ptr2.Number = 2;
  3872.             NewGadget.ng_UserData = &(MyGadget->Ptr2);
  3873.             NewGadget.ng_Width = GADGETWIDTH;
  3874.             NewGadget.ng_Flags = PLACETEXT_IN;
  3875.             NewGadget.ng_GadgetText = (char *)"«";
  3876.             MyGadget->Gadget2 = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  3877.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  3878.                                         TAG_END);
  3879.             NewGadget.ng_Flags = PLACETEXT_LEFT;
  3880.             break;
  3881.         case GAD_OMODE:
  3882.         case GAD_OFONT:
  3883.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  3884.             MyGadget->Ptr1.MyGadget = MyGadget;
  3885.             MyGadget->Ptr1.Number = 1;
  3886.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  3887.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  3888.             NewGadget.ng_Width = GADGETWIDTH;
  3889.             NewGadget.ng_GadgetText = MyGadget->Title;
  3890.             MyGadget->Gadget1 = Gadget = CreateGadget(CHECKBOX_KIND,Gadget,&NewGadget,
  3891.                                         GTCB_Checked, MyGadget->Currentc,
  3892.                                         GTCB_Scaled, TRUE,
  3893.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  3894.                                         GT_Underscore, '_',
  3895.                                         TAG_END);
  3896.             MyGadget->Ptr2.MyGadget = MyGadget;
  3897.             MyGadget->Ptr2.Number = 2;
  3898.             NewGadget.ng_UserData = &(MyGadget->Ptr2);
  3899.             NewGadget.ng_LeftEdge += gh->interwidth/2 + GADGETWIDTH;
  3900.             NewGadget.ng_Width = gh->rightsize - ((gh->interwidth/2 + GADGETWIDTH) * 2);
  3901.             NewGadget.ng_GadgetText = NULL;
  3902.             MyGadget->Gadget2 = Gadget = CreateGadget(TEXT_KIND,Gadget,&NewGadget,
  3903.                                         GTTX_Text, MyGadget->Defaults,
  3904.                                         GTTX_Border, TRUE,
  3905.                                         GA_Disabled,MyGadget->Currentc ? (MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE) : TRUE,
  3906.                                         GT_Underscore, '_',
  3907.                                         TAG_END);
  3908.             NewGadget.ng_LeftEdge += NewGadget.ng_Width + gh->interwidth/2;
  3909.             MyGadget->Ptr3.MyGadget = MyGadget;
  3910.             MyGadget->Ptr3.Number = 3;
  3911.             NewGadget.ng_UserData = &(MyGadget->Ptr3);
  3912.             NewGadget.ng_Width = GADGETWIDTH;
  3913.             NewGadget.ng_Flags = PLACETEXT_IN;
  3914.             NewGadget.ng_GadgetText = (char *)"«";
  3915.             MyGadget->Gadget3 = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  3916.                                         GA_Disabled,MyGadget->Currentc ? (MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE) : TRUE,
  3917.                                         TAG_END);
  3918.             NewGadget.ng_Flags = PLACETEXT_LEFT;
  3919.             break;
  3920.         case GAD_OFILE:
  3921.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  3922.             MyGadget->Ptr1.MyGadget = MyGadget;
  3923.             MyGadget->Ptr1.Number = 1;
  3924.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  3925.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  3926.             NewGadget.ng_Width = GADGETWIDTH;
  3927.             NewGadget.ng_GadgetText = MyGadget->Title;
  3928.             MyGadget->Gadget1 = Gadget = CreateGadget(CHECKBOX_KIND,Gadget,&NewGadget,
  3929.                                         GTCB_Checked, MyGadget->Currentc,
  3930.                                         GTCB_Scaled, TRUE,
  3931.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  3932.                                         GT_Underscore, '_',
  3933.                                         TAG_END);
  3934.             MyGadget->Ptr2.MyGadget = MyGadget;
  3935.             MyGadget->Ptr2.Number = 2;
  3936.             NewGadget.ng_UserData = &(MyGadget->Ptr2);
  3937.             NewGadget.ng_LeftEdge += gh->interwidth/2 + GADGETWIDTH;
  3938.             NewGadget.ng_Width = gh->rightsize - ((gh->interwidth/2 + GADGETWIDTH) * 2);
  3939.             NewGadget.ng_GadgetText = NULL;
  3940.             MyGadget->Gadget2 = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  3941.                                         GTST_String, MyGadget->Defaults,
  3942.                                         GTST_MaxChars, 256,
  3943.                                         GA_Disabled,MyGadget->Currentc ? (MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE) : TRUE,
  3944.                                         STRINGA_ExitHelp, TRUE,
  3945.                                         TAG_END);
  3946.             NewGadget.ng_LeftEdge += NewGadget.ng_Width + gh->interwidth/2;
  3947.             MyGadget->Ptr3.MyGadget = MyGadget;
  3948.             MyGadget->Ptr3.Number = 3;
  3949.             NewGadget.ng_UserData = &(MyGadget->Ptr3);
  3950.             NewGadget.ng_Width = GADGETWIDTH;
  3951.             NewGadget.ng_Flags = PLACETEXT_IN;
  3952.             NewGadget.ng_GadgetText = (char *)"«";
  3953.             MyGadget->Gadget3 = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  3954.                                         GA_Disabled,MyGadget->Currentc ? (MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE) : TRUE,
  3955.                                         TAG_END);
  3956.             NewGadget.ng_Flags = PLACETEXT_LEFT;
  3957.             break;
  3958.         case GAD_ONUMBER:
  3959.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  3960.             MyGadget->Ptr1.MyGadget = MyGadget;
  3961.             MyGadget->Ptr1.Number = 1;
  3962.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  3963.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  3964.             NewGadget.ng_Width = GADGETWIDTH;
  3965.             NewGadget.ng_GadgetText = MyGadget->Title;
  3966.             MyGadget->Gadget1 = Gadget = CreateGadget(CHECKBOX_KIND,Gadget,&NewGadget,
  3967.                                         GTCB_Checked, MyGadget->Currentc,
  3968.                                         GTCB_Scaled, TRUE,
  3969.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  3970.                                         GT_Underscore, '_',
  3971.                                         TAG_END);
  3972.             MyGadget->Ptr2.MyGadget = MyGadget;
  3973.             MyGadget->Ptr2.Number = 2;
  3974.             NewGadget.ng_UserData = &(MyGadget->Ptr2);
  3975.             NewGadget.ng_LeftEdge += gh->interwidth/2 + GADGETWIDTH;
  3976.             NewGadget.ng_Width = gh->rightsize - (GADGETWIDTH + gh->interwidth/2);
  3977.             NewGadget.ng_GadgetText = NULL;
  3978.             MyGadget->Gadget2 = Gadget = CreateGadget(INTEGER_KIND,Gadget,&NewGadget,
  3979.                                         GTIN_Number, MyGadget->Defaultn,
  3980.                                         GA_Disabled,MyGadget->Currentc ? (MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE) : TRUE,
  3981.                                         STRINGA_ExitHelp, TRUE,
  3982.                                         TAG_END);
  3983.             break;
  3984.         case GAD_NUMBER:
  3985.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  3986.             MyGadget->Ptr1.MyGadget = MyGadget;
  3987.             MyGadget->Ptr1.Number = 1;
  3988.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  3989.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  3990.             NewGadget.ng_Width = gh->rightsize;
  3991.             NewGadget.ng_GadgetText = MyGadget->Title;
  3992.             MyGadget->Gadget1 = Gadget = CreateGadget(INTEGER_KIND,Gadget,&NewGadget,
  3993.                                         GTIN_Number, MyGadget->Defaultn,
  3994.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  3995.                                         GT_Underscore, '_',
  3996.                                         STRINGA_ExitHelp, TRUE,
  3997.                                         TAG_END);
  3998.             break;
  3999.         case GAD_CYCLE:
  4000.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4001.             MyGadget->Ptr1.MyGadget = MyGadget;
  4002.             MyGadget->Ptr1.Number = 1;
  4003.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4004.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  4005.             NewGadget.ng_Width = gh->rightsize;
  4006.             NewGadget.ng_GadgetText = MyGadget->Title;
  4007.             MyGadget->Gadget1 = Gadget = CreateGadget(CYCLE_KIND,Gadget,&NewGadget,
  4008.                                         GTCY_Labels, MyGadget->VStrings,
  4009.                                         GTCY_Active, MyGadget->Currenty,
  4010.                                         GT_Underscore, '_',
  4011.                                         TAG_END);
  4012.             break;
  4013.         case GAD_STRING:
  4014.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4015.             MyGadget->Ptr1.MyGadget = MyGadget;
  4016.             MyGadget->Ptr1.Number = 1;
  4017.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4018.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  4019.             NewGadget.ng_Width = gh->rightsize;
  4020.             NewGadget.ng_GadgetText = MyGadget->Title;
  4021.             MyGadget->Gadget1 = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  4022.                                         GTST_String, MyGadget->Defaults,
  4023.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  4024.                                         GT_Underscore, '_',
  4025.                                         STRINGA_ExitHelp, TRUE,
  4026.                                         TAG_END);
  4027.             break;
  4028.         case GAD_TEXT:
  4029.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4030.             MyGadget->Ptr1.MyGadget = MyGadget;
  4031.             MyGadget->Ptr1.Number = 1;
  4032.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4033.             if (*MyGadget->Title) {
  4034.                 NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  4035.                 NewGadget.ng_Width = gh->rightsize;
  4036.             }
  4037.             else {
  4038.                 NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + tleft;
  4039.                 NewGadget.ng_Width = gh->rightsize + gh->leftsize;
  4040.             }
  4041.             NewGadget.ng_GadgetText = MyGadget->Title;
  4042.             MyGadget->Gadget1 = Gadget = CreateGadget(TEXT_KIND,Gadget,&NewGadget,
  4043.                                         GTTX_Text, MyGadget->Defaults,
  4044.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  4045.                                         GT_Underscore, '_',
  4046.                                         GTTX_Border, TRUE,
  4047.                                         GTTX_Justification, MyGadget->Currentc?GTJ_CENTER:GTJ_LEFT,
  4048.                                         TAG_END);
  4049.             break;
  4050.         case GAD_MTEXT:
  4051.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4052.             MyGadget->Ptr1.MyGadget = MyGadget;
  4053.             MyGadget->Ptr1.Number = 1;
  4054.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4055.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + tleft;
  4056.             NewGadget.ng_Width = gh->rightsize + gh->leftsize;
  4057.             NewGadget.ng_GadgetText = "";
  4058.             MyGadget->Gadget1 = Gadget = CreateGadget(TEXT_KIND,Gadget,&NewGadget,
  4059.                                         GTTX_Text, MyGadget->Defaults,
  4060.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  4061.                                         GT_Underscore, '_',
  4062.                                         GTTX_Border, FALSE,
  4063.                                         GTTX_Justification, MyGadget->Currentc?GTJ_CENTER:GTJ_LEFT,
  4064.                                         TAG_END);
  4065.             break;
  4066.         case GAD_OSTRING:
  4067.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4068.             MyGadget->Ptr1.MyGadget = MyGadget;
  4069.             MyGadget->Ptr1.Number = 1;
  4070.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4071.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  4072.             NewGadget.ng_Width = GADGETWIDTH;
  4073.             NewGadget.ng_GadgetText = MyGadget->Title;
  4074.             MyGadget->Gadget1 = Gadget = CreateGadget(CHECKBOX_KIND,Gadget,&NewGadget,
  4075.                                         GTCB_Checked, MyGadget->Currentc,
  4076.                                         GTCB_Scaled, TRUE,
  4077.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  4078.                                         GT_Underscore, '_',
  4079.                                         TAG_END);
  4080.             MyGadget->Ptr2.MyGadget = MyGadget;
  4081.             MyGadget->Ptr2.Number = 2;
  4082.             NewGadget.ng_UserData = &(MyGadget->Ptr2);
  4083.             NewGadget.ng_LeftEdge += gh->interwidth/2 + GADGETWIDTH;
  4084.             NewGadget.ng_Width = gh->rightsize - (GADGETWIDTH + gh->interwidth/2);
  4085.             NewGadget.ng_GadgetText = NULL;
  4086.             MyGadget->Gadget2 = Gadget = CreateGadget(STRING_KIND,Gadget,&NewGadget,
  4087.                                         GTST_String, MyGadget->Defaults,
  4088.                                         GA_Disabled,MyGadget->Currentc ? (MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE) : TRUE,
  4089.                                         STRINGA_ExitHelp, TRUE,
  4090.                                         TAG_END);
  4091.             break;
  4092.         case GAD_CHECK:
  4093.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4094.             MyGadget->Ptr1.MyGadget = MyGadget;
  4095.             MyGadget->Ptr1.Number = 1;
  4096.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4097.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  4098.             NewGadget.ng_Width = GADGETWIDTH;
  4099.             NewGadget.ng_GadgetText = MyGadget->Title;
  4100.             MyGadget->Gadget1 = Gadget = CreateGadget(CHECKBOX_KIND,Gadget,&NewGadget,
  4101.                                         GTCB_Checked, MyGadget->Currentc,
  4102.                                         GTCB_Scaled, TRUE,
  4103.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  4104.                                         GT_Underscore, '_',
  4105.                                         TAG_END);
  4106.             break;
  4107.         case GAD_SLIDER:
  4108.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4109.             MyGadget->Ptr1.MyGadget = MyGadget;
  4110.             MyGadget->Ptr1.Number = 1;
  4111.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4112.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  4113.             NewGadget.ng_Width = gh->rightsize - 
  4114.                                         (gh->UseTopaz ? (gh->XSize * MyGadget->logMaxn) : (TextLength(&(gh->MyScreen->RastPort),NUMBER,strlen(NUMBER))* MyGadget->logMaxn/10))
  4115.                                         - gh->interwidth;
  4116.             NewGadget.ng_GadgetText = MyGadget->Title;
  4117.             MyGadget->Gadget1 = Gadget = CreateGadget(SLIDER_KIND,Gadget,&NewGadget,
  4118.                                         GTSL_Min, MyGadget->Minn,
  4119.                                         GTSL_Max, MyGadget->Maxn,
  4120.                                         GTSL_Level, MyGadget->Defaultn,
  4121.                                         GTSL_MaxLevelLen, MyGadget->logMaxn,
  4122.                                         GTSL_MaxPixelLen, gh->UseTopaz ? (gh->XSize*MyGadget->logMaxn+2) : (TextLength(&(gh->MyScreen->RastPort),"8",1)* MyGadget->logMaxn + 2),
  4123.                                         GTSL_LevelFormat, "%ld",
  4124.                                         GTSL_LevelPlace, PLACETEXT_RIGHT,
  4125.                                         GA_RelVerify, TRUE,
  4126.                                         PGA_Freedom, LORIENT_HORIZ,
  4127.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  4128.                                         GT_Underscore, '_',
  4129.                                         TAG_END);
  4130.             break;
  4131.         case GAD_LIST:
  4132.         case GAD_MLIST:
  4133.             temp = NewGadget.ng_Height;
  4134.             NewGadget.ng_GadgetText = MyGadget->Title;
  4135.             NewGadget.ng_Height = (MyGadget->Lines * gh->MyTextAttr->ta_YSize) + 4;
  4136.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4137.             MyGadget->Ptr1.MyGadget = MyGadget;
  4138.             MyGadget->Ptr1.Number = 1;
  4139.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4140.             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  4141.             NewGadget.ng_Width = gh->rightsize;
  4142.             MyGadget->Gadget1 = Gadget = CreateGadget(LISTVIEW_KIND,Gadget,&NewGadget,
  4143.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  4144.                                         GTLV_MakeVisible, MyGadget->Currenty,
  4145.                                         GTLV_Labels, &(MyGadget->VList),
  4146.                                         GTLV_ShowSelected, NULL,
  4147.                                         GTLV_Selected, MyGadget->Currenty,
  4148.                                         GT_Underscore, '_',
  4149.                                         (GAD_MLIST==MyGadget->Type)?GTLV_CallBack:TAG_IGNORE, (ULONG)&HookList,
  4150.                                         TAG_END);
  4151.             gh->height += NewGadget.ng_Height - 2;
  4152.             NewGadget.ng_Height = temp;
  4153.             break;
  4154.         case GAD_BUTTONTEXT:
  4155.             InButton = TRUE;
  4156.             ButtonNo = 0;
  4157.             checkleft(gh,NewGadget.ng_Height,&(NewGadget.ng_TopEdge),&tleft);
  4158.             if (*MyGadget->Title) {    
  4159.                 NewGadget.ng_GadgetText = "";
  4160.                 MyGadget->Ptr1.MyGadget = MyGadget;
  4161.                 MyGadget->Ptr1.Number = 1;
  4162.                 NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4163.                 NewGadget.ng_LeftEdge = max(gh->MyScreen->WBorLeft + gh->interwidth + tleft - INTERWIDTH,0);
  4164.                 NewGadget.ng_Width = gh->leftsize;
  4165.                 MyGadget->Gadget1 = Gadget = Gadget = CreateGadget(TEXT_KIND,Gadget,&NewGadget,
  4166.                                         GTTX_Text, MyGadget->Title,
  4167.                                         GTTX_Border, FALSE,
  4168.                                         GTTX_Justification, GTJ_RIGHT,
  4169.                                         GTTX_Clipped, TRUE,
  4170.                                         TAG_END);
  4171.                 NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft;
  4172.             }
  4173.             else {
  4174.                 NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + tleft;
  4175.             }
  4176.             if (MyGadget->ButtonCount > 1) {
  4177.                 struct MyGadget *gad1;
  4178.                 int MaxWidth = 0;
  4179.                 int t;
  4180.                 for (gad1 = (struct MyGadget *)MyGadget->GNode.ln_Succ;
  4181.                       gad1->GNode.ln_Succ && (GAD_BUTTON == gad1->Type);
  4182.                       gad1 = (struct MyGadget *)gad1->GNode.ln_Succ) {
  4183.                     if (gh->UseTopaz) {
  4184.                         t = gh->XSize*strlen(gad1->Title) + INTERWIDTH;
  4185.                     }
  4186.                     else {
  4187.                         t = TextLength(&(gh->MyScreen->RastPort),gad1->Title,strlen(gad1->Title)) + INTERWIDTH;
  4188.                     }
  4189.                     if (t > MaxWidth) {
  4190.                         MaxWidth = t;
  4191.                     }
  4192.                 }
  4193.                 t = (MaxWidth + gh->interwidth) * MyGadget->ButtonCount - gh->interwidth;
  4194.                 if (*MyGadget->Title) {
  4195.                     if (t <= gh->rightsize) {
  4196.                         ButtonWidth = MaxWidth;
  4197.                     }
  4198.                     else {
  4199.                         ButtonWidth = 0;
  4200.                     }
  4201.                 }
  4202.                 else {
  4203.                     if (t <= (gh->rightsize+gh->leftsize)) {
  4204.                         ButtonWidth = MaxWidth;
  4205.                     }
  4206.                     else {
  4207.                         ButtonWidth = 0;
  4208.                     }
  4209.                 }
  4210.             }
  4211.             break;
  4212.         case GAD_BUTTON:
  4213.             NewGadget.ng_GadgetText = MyGadget->Title;
  4214.             MyGadget->Ptr1.MyGadget = MyGadget;
  4215.             MyGadget->Ptr1.Number = 1;
  4216.             NewGadget.ng_UserData = &(MyGadget->Ptr1);
  4217.             if (MyGadget->OwnButton->ButtonCount > 1) {
  4218.                 if (ButtonWidth) {
  4219.                     NewGadget.ng_Width = ButtonWidth;
  4220.                 }
  4221.                 else {
  4222.                     if (gh->UseTopaz) {
  4223.                         NewGadget.ng_Width = gh->XSize*strlen(MyGadget->Title) + INTERWIDTH;
  4224.                     }
  4225.                     else {
  4226.                         NewGadget.ng_Width = TextLength(&(gh->MyScreen->RastPort),MyGadget->Title,strlen(MyGadget->Title)) + INTERWIDTH;
  4227.                     }
  4228.                 }
  4229.             }
  4230.             else {
  4231.                 if (*MyGadget->OwnButton->Title) {
  4232.                     NewGadget.ng_Width = gh->rightsize;
  4233.                 }
  4234.                 else {
  4235.                     NewGadget.ng_Width = gh->rightsize + gh->leftsize;
  4236.                 }
  4237.             }
  4238.             if (ButtonNo) {
  4239.                 if (MyGadget->OwnButton->ButtonCount == 2) {
  4240.                     NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize +
  4241.                                                     gh->rightsize + tleft - NewGadget.ng_Width;
  4242.                 }
  4243.                 else if (MyGadget->OwnButton->ButtonCount == 3) {
  4244.                     if (1 == ButtonNo) {
  4245.                         if (*MyGadget->OwnButton->Title) {
  4246.                             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize + tleft +
  4247.                                                             (gh->rightsize - NewGadget.ng_Width)/2;
  4248.                         }
  4249.                         else {
  4250.                             NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + tleft +
  4251.                                                             (gh->leftsize + gh->rightsize - NewGadget.ng_Width)/2;
  4252.                         }
  4253.                     }
  4254.                     else if (2 == ButtonNo) {
  4255.                         NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth + gh->leftsize +
  4256.                                                         gh->rightsize + tleft - NewGadget.ng_Width;
  4257.                     }
  4258.                 }
  4259.             }
  4260.             NewGadget.ng_GadgetText = MyGadget->Title;
  4261.             NewGadget.ng_Flags = PLACETEXT_IN;
  4262.             MyGadget->Gadget1 = Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  4263.                                         GA_Disabled, MyGadget->OwnCycle ?((MyGadget->OwnCycle->Currenty == MyGadget->Activey) ? FALSE : TRUE ) : FALSE,
  4264.                                         GT_Underscore, '_',
  4265.                                         TAG_END);
  4266.             NewGadget.ng_Flags = PLACETEXT_LEFT;
  4267.             NewGadget.ng_LeftEdge += NewGadget.ng_Width + gh->interwidth;
  4268.             ++ButtonNo;
  4269.             break;
  4270.         }
  4271.         if (!InButton) {
  4272.             if ((MyGadget->Type != GAD_LIST) &&
  4273.                  (MyGadget->Type != GAD_MLIST)) {
  4274.                 gh->height += gh->MyTextAttr->ta_YSize + 2;
  4275.             }
  4276.         }
  4277.     }
  4278.     if (InButton) {
  4279.         gh->height += gh->MyTextAttr->ta_YSize + 2;
  4280.     }
  4281.     if (gh->Bottom) {
  4282.         gh->height = gh->Bottom;
  4283.     }
  4284.     gh->height += gh->interheight*2;
  4285.     NewGadget.ng_Flags = PLACETEXT_IN;
  4286.     if (!gh->NoButtons && Gadget) {
  4287.         NewGadget.ng_TopEdge = gh->height;
  4288.         NewGadget.ng_UserData = (APTR)USERSAVE;
  4289.         NewGadget.ng_LeftEdge = gh->MyScreen->WBorLeft + gh->interwidth;
  4290.         NewGadget.ng_Width = CancelSize;
  4291.         if (gh->Prefs) {
  4292.             NewGadget.ng_GadgetText = (gh->NoSave?GetMessage(MSG_SAVE):GetMessage(MSG__SAVE));
  4293.         }
  4294.         else {
  4295.             NewGadget.ng_GadgetText = (gh->NoOk?GetMessage(MSG_OK):GetMessage(MSG__OK));
  4296.         }
  4297.         Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  4298.                                 GT_Underscore, '_',
  4299.                                 TAG_END);
  4300.         if (Gadget) {
  4301.             if (gh->Prefs) {
  4302.                 NewGadget.ng_UserData = (APTR)USERUSE;
  4303.                 NewGadget.ng_LeftEdge = (gh->width - CancelSize)/2;
  4304.                 NewGadget.ng_GadgetText = (gh->NoUse?GetMessage(MSG_USE):GetMessage(MSG__USE));
  4305.                 Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  4306.                                         GT_Underscore, '_',
  4307.                                         TAG_END);
  4308.             }
  4309.             else {
  4310.                 if (gh->HelpFunc && gh->HelpNode) {
  4311.                     NewGadget.ng_UserData = (APTR)USERHELP;
  4312.                     NewGadget.ng_LeftEdge = (gh->width - CancelSize)/2;
  4313.                     NewGadget.ng_GadgetText = GetMessage(MSG_HELP);
  4314.                     Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  4315.                                             TAG_END);
  4316.                 }
  4317.             }
  4318.             if (Gadget) {
  4319.                 NewGadget.ng_UserData = (APTR)USERCANCEL;
  4320.                 NewGadget.ng_LeftEdge = gh->width - gh->interwidth - gh->MyScreen->WBorRight - CancelSize;
  4321.                 NewGadget.ng_GadgetText = (gh->NoCancel?GetMessage(MSG_CANCEL):GetMessage(MSG__CANCEL));
  4322.                 Gadget = CreateGadget(BUTTON_KIND,Gadget,&NewGadget,
  4323.                                         GT_Underscore, '_',
  4324.                                         TAG_END);
  4325.             }
  4326.         }
  4327.         gh->height += gh->MyTextAttr->ta_YSize + 2 + gh->MyScreen->WBorBottom + gh->interheight;
  4328.     }
  4329.     else {
  4330.         gh->height += gh->MyScreen->WBorBottom;
  4331.     }
  4332.     return (BOOL)Gadget;
  4333. }
  4334.  
  4335. static void
  4336. checkleft(struct MPGuiHandle *gh, int addheight, short *curgh, int *tleft) {
  4337.     if ((gh->height + gh->MyScreen->WBorBottom + gh->interheight + addheight +
  4338.           (gh->NoButtons?0:(gh->MyTextAttr->ta_YSize + 2 + gh->interheight))) > gh->MyScreen->Height) {
  4339.         if ((gh->height + addheight) > gh->Bottom) {
  4340.             gh->Bottom = gh->height;
  4341.         }
  4342.         gh->height = gh->MyScreen->WBorTop + gh->MyScreen->Font->ta_YSize + 1 + gh->interheight;
  4343.         *curgh = gh->height;
  4344.         *tleft += gh->leftsize + gh->rightsize + gh->interwidth;
  4345.         gh->width += gh->leftsize + gh->rightsize + gh->interwidth;
  4346.         if (gh->width > gh->MyScreen->Width) {
  4347.             gh->width -= gh->interwidth;
  4348.             *tleft -= gh->interwidth;
  4349.         }
  4350.         if (gh->width > gh->MyScreen->Width) {
  4351.             gh->rightsize -= (gh->width - gh->MyScreen->Width);
  4352.             gh->width = gh->MyScreen->Width;
  4353.         }
  4354.     }
  4355.     return;
  4356. }
  4357.  
  4358. /* Shows ASL file requester for a file
  4359.  * name    : current file name
  4360.  * Prompt: Title
  4361.  * flags    : e.g. for save flag
  4362.  * Returns: TRUE if file selected, name is TempFileName
  4363.  */
  4364. BOOL
  4365. GetAFile(struct MPGuiHandle *gh,const UBYTE *name,const char *Prompt,ULONG flags,char *positive) {
  4366.     char TempName[257];
  4367.     char TempDir[257];
  4368.  
  4369.     if (name && *name) {
  4370.         strncpy(TempDir,name,(size_t)(PathPart((char *)name) - name));
  4371.         TempDir[PathPart((char *)name)-name]=0;
  4372.         strcpy(TempName,FilePart((char *)name));
  4373.     }
  4374.     else {
  4375.         TempDir[0]=0;
  4376.         TempName[0]=0;
  4377.     }
  4378.     // Show requesters
  4379.     DisableWindow(gh);
  4380.     if (AslRequestTags((APTR) gh->filereq,
  4381.                             ASLFR_TitleText,(Tag) Prompt,
  4382.                             ASLFR_Flags1,flags,
  4383.                             ASLFR_InitialDrawer, (Tag) TempDir,
  4384.                             ASLFR_InitialFile,(Tag) TempName,
  4385.                             ASLFR_Window, gh->Window,
  4386.                             ASLFR_RejectIcons, TRUE,
  4387.                             ASLFR_PositiveText, positive,
  4388.                             ASLFR_IntuiMsgFunc, &(gh->RefreshHook),
  4389.                             TAG_DONE)) {
  4390.         // rejoin name
  4391.         strncpy(gh->TempFileName,gh->filereq->fr_Drawer,256);
  4392.         AddPart(gh->TempFileName,gh->filereq->fr_File,256);
  4393.         EnableWindow(gh);
  4394.         return TRUE;
  4395.     }
  4396.     else {
  4397.     EnableWindow(gh);
  4398.     return FALSE;
  4399.     }
  4400. }
  4401.  
  4402. /* Shows ASL file requester for a font
  4403.  * name    : current font name
  4404.  * Prompt: Title
  4405.  * Returns: TRUE if font selected, constructed name is gh->TempFileName
  4406.  */
  4407. BOOL
  4408. GetAFont(struct MPGuiHandle *gh,struct MyGadget *mg,const UBYTE *name,const char *Prompt) {
  4409.     char TempName[257];
  4410.     struct FontRequester *req;
  4411.  
  4412.     if (name && *name) {
  4413.         strcpy(TempName,name);
  4414.     }
  4415.     else {
  4416.         TempName[0]=0;
  4417.     }
  4418.     // Show requesters
  4419.     DisableWindow(gh);
  4420.     if (req = AllocAslRequest(ASL_FontRequest,NULL)) {
  4421.         if (AslRequestTags(req,
  4422.                             ASLFO_Window, gh->Window,
  4423.                             ASLFO_TitleText, Prompt,
  4424.                             ASLFO_InitialName, TempName,
  4425.                             ASLFO_InitialSize, 8,    //??
  4426.                             ASLFO_FixedWidthOnly, (mg->ModeType > 1),
  4427.                             ASLFO_PositiveText,GetMessage(MSG_SELECT),
  4428.                             ASLFO_IntuiMsgFunc, &(gh->RefreshHook),
  4429.                             TAG_END)) {
  4430.             strcpy(gh->TempFileName,req->fo_Attr.ta_Name);
  4431.             if (strlen(gh->TempFileName) > 5) {
  4432.                 if (!stricmp(&(gh->TempFileName[strlen(gh->TempFileName)-5]),".font")) {
  4433.                     gh->TempFileName[strlen(gh->TempFileName)-5] = 0;
  4434.                 }
  4435.             }
  4436.             FreeAslRequest(req);
  4437.             EnableWindow(gh);
  4438.             return TRUE;
  4439.         }
  4440.         else {
  4441.             FreeAslRequest(req);
  4442.             EnableWindow(gh);
  4443.             return FALSE;
  4444.         }
  4445.     }
  4446.     else {
  4447.         return FALSE;
  4448.     }
  4449. }
  4450.  
  4451. /* Shows ASL file requester for a font
  4452.  * name    : current font name
  4453.  * Prompt: Title
  4454.  * Returns: TRUE if file selected, name is TempFileName
  4455.  */
  4456. BOOL
  4457. GetAMode(struct MPGuiHandle *gh,struct MyGadget *mg,const UBYTE *name,const char *Prompt) {
  4458.     char TempName[257];
  4459.  
  4460.     if (name && *name) {
  4461.         strcpy(TempName,name);
  4462.     }
  4463.     else {
  4464.         TempName[0]=0;
  4465.     }
  4466.     // Show requesters
  4467.     DisableWindow(gh);
  4468.     {
  4469.         ULONG id = (ULONG)INVALID_ID;
  4470.         ULONG myid = (ULONG)INVALID_ID;
  4471.         struct NameInfo buff;
  4472.         struct List List = {0};
  4473.         struct DisplayMode DisplayMode = {0};
  4474.         struct ScreenModeRequester *req;
  4475.  
  4476.         NewList(&List);
  4477.         DisplayMode.dm_Node.ln_Name = GetMessage(MSG_NONE);
  4478.       DisplayMode.dm_PropertyFlags                     = DIPF_IS_WB;
  4479.         DisplayMode.dm_DimensionInfo.Header.StructID        = DTAG_DIMS;
  4480.         DisplayMode.dm_DimensionInfo.Header.DisplayID    = (ULONG)INVALID_ID;
  4481.         DisplayMode.dm_DimensionInfo.Header.SkipID         = TAG_SKIP;
  4482.       DisplayMode.dm_DimensionInfo.Header.Length        = sizeof(struct DimensionInfo);
  4483.       DisplayMode.dm_DimensionInfo.MaxDepth         = 24;
  4484.       DisplayMode.dm_DimensionInfo.MinRasterWidth   = 16;
  4485.       DisplayMode.dm_DimensionInfo.MinRasterHeight  = 16;
  4486.       DisplayMode.dm_DimensionInfo.MaxRasterWidth   = 2048;
  4487.       DisplayMode.dm_DimensionInfo.MaxRasterHeight  = 2048;
  4488.       DisplayMode.dm_DimensionInfo.Nominal.MinX     = 0;
  4489.       DisplayMode.dm_DimensionInfo.Nominal.MinY     = 0;
  4490.       DisplayMode.dm_DimensionInfo.Nominal.MaxX     = 640;
  4491.       DisplayMode.dm_DimensionInfo.Nominal.MaxY     = 200;
  4492.       DisplayMode.dm_DimensionInfo.TxtOScan         = DisplayMode.dm_DimensionInfo.Nominal;
  4493.       DisplayMode.dm_DimensionInfo.MaxOScan         = DisplayMode.dm_DimensionInfo.Nominal;
  4494.       DisplayMode.dm_DimensionInfo.VideoOScan       = DisplayMode.dm_DimensionInfo.Nominal;
  4495.       DisplayMode.dm_DimensionInfo.StdOScan         = DisplayMode.dm_DimensionInfo.Nominal;
  4496.         AddHead(&List,&(DisplayMode.dm_Node));
  4497.  
  4498.         id = NextDisplayInfo(id);
  4499.         while ((id != INVALID_ID) && (myid == INVALID_ID)) {
  4500.             if (GetDisplayInfoData(NULL,(UBYTE *)&buff,sizeof(struct NameInfo),DTAG_NAME,id)) {
  4501.                 if (!Stricmp(TempName,buff.Name)) {
  4502.                     myid = id;
  4503.                 }
  4504.             }
  4505.             id = NextDisplayInfo(id);
  4506.         }
  4507.         if (req = AllocAslRequest(ASL_ScreenModeRequest,NULL)) {
  4508.             if (AslRequestTags(req,
  4509.                                 ASLSM_Window, gh->Window,
  4510.                                 ASLSM_TitleText, Prompt,
  4511.                                 ASLSM_InitialDisplayID, myid,
  4512.                                 ((mg->ModeType == 2) || (mg->ModeType == 4)) ? ASLSM_CustomSMList : TAG_IGNORE,
  4513.                                     (ULONG)&List,
  4514.                                 (mg->ModeType > 2) ? ASLSM_PropertyFlags : TAG_IGNORE , NULL,
  4515.                                 (mg->ModeType > 2) ? ASLSM_PropertyMask : TAG_IGNORE, NULL,
  4516.                                 ASLSM_PositiveText,GetMessage(MSG_SELECT),
  4517.                                 ASLSM_IntuiMsgFunc, &(gh->RefreshHook),
  4518.                                 TAG_END)) {
  4519.                 if (GetDisplayInfoData(NULL,(UBYTE *)&buff,sizeof(struct NameInfo),DTAG_NAME,
  4520.                         req->sm_DisplayID)) {
  4521.                     strcpy(gh->TempFileName, buff.Name);
  4522.                 }
  4523.                 else {
  4524.                     strcpy(gh->TempFileName,"");
  4525.                 }
  4526.                 FreeAslRequest(req);
  4527.                 EnableWindow(gh);
  4528.                 return TRUE;
  4529.             }
  4530.             else {
  4531.                 FreeAslRequest(req);
  4532.                 EnableWindow(gh);
  4533.                 return FALSE;
  4534.             }
  4535.         }
  4536.         else {
  4537.             return FALSE;
  4538.         }
  4539.     }
  4540. }
  4541.  
  4542. void
  4543. DisableWindow(struct MPGuiHandle *gh) {
  4544.     InitRequester(&gh->Requestx);
  4545.     SetWindowPointer(gh->Window, WA_BusyPointer, TRUE, TAG_DONE);
  4546.     if (!gh->Disabled) {
  4547.         if (Request(&gh->Requestx,gh->Window)) {
  4548.             gh->Disabled = 1;
  4549.         }
  4550.     }
  4551.     else {
  4552.         ++gh->Disabled;
  4553.     }
  4554. }    
  4555.  
  4556. void
  4557. EnableWindow(struct MPGuiHandle *gh) {
  4558.     if (gh->Disabled) {
  4559.         --gh->Disabled;
  4560.     }
  4561.     if (!gh->Disabled) {
  4562.         SetWindowPointer(gh->Window,WA_Pointer, NULL, TAG_DONE);
  4563.         EndRequest(&gh->Requestx,gh->Window);
  4564.     }
  4565. }
  4566.  
  4567. ULONG
  4568. MyCallHookPkt(struct MPGuiHandle *gh,struct Hook *h,APTR a,APTR b) {
  4569.     ULONG ret;
  4570.     DisableWindow(gh);
  4571.     ret = CallHookPkt(h,a,b);
  4572.     EnableWindow(gh);
  4573.     return ret;
  4574. }
  4575.  
  4576. char
  4577. *GetMessage(UWORD message) {
  4578.     LONG   *l;
  4579.     UWORD  *w;
  4580.     STRPTR  builtIn;
  4581.  
  4582.    l = (LONG *)CatCompBlock;
  4583.  
  4584.     while (*l != message)  {
  4585.         w = (UWORD *)((ULONG)l + 4);
  4586.         l = (LONG *)((ULONG)l + (ULONG)*w + 6);
  4587.     }
  4588.     builtIn = (STRPTR)((ULONG)l + 6);
  4589.     return(GetCatalogStr(Catalog,message,builtIn));
  4590. }
  4591.